1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

/*
  ReadATweet

 Demonstrates retrieving the most recent Tweet from a user's home timeline 
 using the Temboo Arduino Yun SDK.

 This example code is in the public domain.
 */

#include <Bridge.h>
#include <Temboo.h>
#include "TembooAccount.h" // contains Temboo account information

/*** SUBSTITUTE YOUR VALUES BELOW: ***/

// Note that for additional security and reusability, you could
// use #define statements to specify these values in a .h file.
constStringTWITTER_ACCESS_TOKEN="5ghgfhgfhgfhgfhgfhgfhgfhgfhgfhgfhghfgJ";
constStringTWITTER_ACCESS_TOKEN_SECRET="9xSrXMhIhgjdfkjghdfgjdfkljgXrgumB24";
constStringTWITTER_CONSUMER_KEY="ECfgkjhdfkjgjdfhgkjdhfkrQ";
constStringTWITTER_CONSUMER_SECRET="Tt9lgfjdfklgjdfkljgfkGjU";

Stringlast_author;
Stringlast_tweet;

unsignedchardim_val=0;
unsignedchardim_dir=0;
unsignedchardim_state=1;
unsignedintloop_ctr=0;

voidsetup(){
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);

Bridge.begin();
}
voidloop()
{

TembooChoreoHomeTimelineChoreo;
if(loop_ctr==650){// wait 65 seconds between HomeTimeline calls
loop_ctr=0;
// invoke the Temboo client.
// NOTE that the client must be reinvoked, and repopulated with
// appropriate arguments, each time its run() method is called.
HomeTimelineChoreo.begin();

// set Temboo account credentials
HomeTimelineChoreo.setAccountName(TEMBOO_ACCOUNT);
HomeTimelineChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);
HomeTimelineChoreo.setAppKey(TEMBOO_APP_KEY);

// tell the Temboo client which Choreo to run (Twitter > Timelines > HomeTimeline)
HomeTimelineChoreo.setChoreo("/Library/Twitter/Timelines/Mentions");

// set the required choreo inputs
// see https://www.temboo.com/library/Library/Twitter/Timelines/HomeTimeline/
// for complete details about the inputs for this Choreo

HomeTimelineChoreo.addInput("Count","1");// the max number of Tweets to return from each request
HomeTimelineChoreo.addInput("AccessToken",TWITTER_ACCESS_TOKEN);
HomeTimelineChoreo.addInput("AccessTokenSecret",TWITTER_ACCESS_TOKEN_SECRET);
HomeTimelineChoreo.addInput("ConsumerKey",TWITTER_CONSUMER_KEY);
HomeTimelineChoreo.addInput("ConsumerSecret",TWITTER_CONSUMER_SECRET);

// next, we'll define two output filters that let us specify the 
// elements of the response from Twitter that we want to receive.
// see the examples at http://www.temboo.com/arduino
// for more on using output filters

// we want the text of the tweet
HomeTimelineChoreo.addOutputFilter("tweet","/[1]/text","Response");

// and the name of the author
HomeTimelineChoreo.addOutputFilter("author","/[1]/user/screen_name","Response");


// tell the Process to run and wait for the results. The 
// return code will tell us whether the Temboo client 
// was able to send our request to the Temboo servers
unsignedintreturnCode=HomeTimelineChoreo.run();

// a response code of 0 means success; print the API response
if(returnCode==0){

Stringauthor;// a String to hold the tweet author's name
Stringtweet;// a String to hold the text of the tweet


// choreo outputs are returned as key/value pairs, delimited with 
// newlines and record/field terminator characters, for example:
// Name1\n\x1F
// Value1\n\x1E
// Name2\n\x1F
// Value2\n\x1E      

// see the examples at http://www.temboo.com/arduino for more details
// we can read this format into separate variables, as follows:
while(HomeTimelineChoreo.available()){
// read the name of the output item
Stringname=HomeTimelineChoreo.readStringUntil('\x1F');
name.trim();

// read the value of the output item
Stringdata=HomeTimelineChoreo.readStringUntil('\x1E');
data.trim();

// assign the value to the appropriate String
if(name=="tweet"){
tweet=data;
}
elseif(name=="author"){
author=data;
}
}

if((last_author==author)&&(last_tweet==tweet)){
//Nothing new
dim_state=0;//Turn off the lamp now
}
elseif(author=="ZeniaIrani"){//New Tweet from Zenia
last_tweet=tweet;
last_author=author;
dim_state=1;
}
else{//New Tweet but not from Zenia
last_tweet=tweet;
last_author=author;
dim_state=0;
}
}
else{
// there was an error
dim_state=0;
}

HomeTimelineChoreo.close();
}

if(dim_state==1){//Yes we must blink the lamp

if(dim_dir==0){
dim_val=dim_val+1;
}
else{
dim_val=dim_val-1;
}


if(dim_val==16){
dim_dir=1;
dim_val=15;
}
elseif(dim_val==0){
dim_dir=0;
dim_val=1;
}


if((dim_val&0x01)==0x01){
digitalWrite(2,HIGH);
}
else{
digitalWrite(2,LOW);
}

if((dim_val&0x02)==0x02){
digitalWrite(3,HIGH);
}
else{
digitalWrite(3,LOW);
}

if((dim_val&0x04)==0x04){
digitalWrite(4,HIGH);
}
else{
digitalWrite(4,LOW);
}

if((dim_val&0x08)==0x08){
digitalWrite(5,HIGH);
}
else{
digitalWrite(5,LOW);
}
}
elseif(dim_state==0){//Turn off the lamp
digitalWrite(2,HIGH);
digitalWrite(3,HIGH);
digitalWrite(4,HIGH);
digitalWrite(5,HIGH);
}
delay(100);
loop_ctr=loop_ctr+1;
}

1
2
3

#define TEMBOO_ACCOUNT "lithiumhead"  // your Temboo account name 
#define TEMBOO_APP_KEY_NAME "Zenomania"  // your Temboo app key name
#define TEMBOO_APP_KEY  "fgdfsgdfgdfgdfgdffgdfgc"  // your Temboo app key

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

#include <net/genetlink.h>
#include <linux/module.h>
#include <linux/kernel.h>

//Code based on http://people.ee.ethz.ch/~arkeller/linux/multi/kernel_user_space_howto-3.html

/* attributes (variables):
 * the index in this enum is used as a reference for the type,
 * userspace application has to indicate the corresponding type
 * the policy is used for security considerations 
 */
enum{
DOC_EXMPL_A_UNSPEC,
DOC_EXMPL_A_MSG,
__DOC_EXMPL_A_MAX,
};
#define DOC_EXMPL_A_MAX (__DOC_EXMPL_A_MAX - 1)

/* attribute policy: defines which attribute has which type (e.g int, char * etc)
 * possible values defined in net/netlink.h 
 */
staticstructnla_policydoc_exmpl_genl_policy[DOC_EXMPL_A_MAX+1]={
[DOC_EXMPL_A_MSG]={.type=NLA_NUL_STRING},
};

#define VERSION_NR 1
//family definition
staticstructgenl_familydoc_exmpl_gnl_family={
.id=GENL_ID_GENERATE,//Genetlink should generate an id
.hdrsize=0,
.name="CONTROL_EXMPL",//The name of this family, used by userspace application
.version=VERSION_NR,//Version number  
.maxattr=DOC_EXMPL_A_MAX,
};

/* commands: enumeration of all commands (functions), 
 * used by userspace application to identify command to be executed
 */
enum{
DOC_EXMPL_C_UNSPEC,
DOC_EXMPL_C_ECHO,
__DOC_EXMPL_C_MAX,
};
#define DOC_EXMPL_C_MAX (__DOC_EXMPL_C_MAX - 1)


//An echo command, receives a message, prints it and sends another message back
intdoc_exmpl_echo(structsk_buff*skb_2,structgenl_info*info){
structnlattr*na;
structsk_buff*skb;
intrc;
void*msg_head;
char*mydata;

if(info==NULL){
gotoout;
}

/* For each attribute there is an index in info->attrs which points to a nlattr structure
     * in this structure the data is given
     */
na=info->attrs[DOC_EXMPL_A_MSG];
if(na){
mydata=(char*)nla_data(na);
if(mydata==NULL){
printk("error while receiving data\n");
}else{
printk("received: %s\n",mydata);
}
}else{
printk("no info->attrs %i\n",DOC_EXMPL_A_MSG);
}

//Send a message back
//Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
skb=genlmsg_new(NLMSG_GOODSIZE,GFP_KERNEL);
if(skb==NULL){
gotoout;
}

//Create the message headers
/* arguments of genlmsg_put: 
       struct sk_buff *, 
       int (sending) pid, 
       int sequence number, 
       struct genl_family *, 
       int flags, 
       u8 command index (why do we need this?)
    */
msg_head=genlmsg_put(skb,0,info->snd_seq+1,&doc_exmpl_gnl_family,0,DOC_EXMPL_C_ECHO);
if(msg_head==NULL){
rc=-ENOMEM;
gotoout;
}
//Add a DOC_EXMPL_A_MSG attribute (actual value to be sent)
rc=nla_put_string(skb,DOC_EXMPL_A_MSG,"Hello World from kernel space");
if(rc!=0){
gotoout;
}

//Finalize the message
genlmsg_end(skb,msg_head);

//Send the message back
rc=genlmsg_unicast(genl_info_net(info),skb,info->snd_pid);
if(rc!=0){
gotoout;
}
return0;

out:
printk("An error occured in doc_exmpl_echo:\n");
return0;
}

//Commands: mapping between the command enumeration and the actual function
structgenl_opsdoc_exmpl_gnl_ops_echo={
.cmd=DOC_EXMPL_C_ECHO,
.flags=0,
.policy=doc_exmpl_genl_policy,
.doit=doc_exmpl_echo,
.dumpit=NULL,
};

staticint__initgnKernel_init(void){
intrc;
printk("Generic Netlink Example Module inserted.\n");

//Register the new family
rc=genl_register_family(&doc_exmpl_gnl_family);
if(rc!=0){
gotofailure;
}
//Register functions (commands) of the new family
rc=genl_register_ops(&doc_exmpl_gnl_family,&doc_exmpl_gnl_ops_echo);
if(rc!=0){
printk("Register ops: %i\n",rc);
genl_unregister_family(&doc_exmpl_gnl_family);
gotofailure;
}
return0;
failure:
printk("An error occured while inserting the generic netlink example module\n");
return-1;
}

staticvoid__exitgnKernel_exit(void){
intret;
printk("Generic Netlink Example Module unloaded.\n");

//Unregister the functions
ret=genl_unregister_ops(&doc_exmpl_gnl_family,&doc_exmpl_gnl_ops_echo);
if(ret!=0){
printk("Unregister ops: %i\n",ret);
}

//Unregister the family
ret=genl_unregister_family(&doc_exmpl_gnl_family);
if(ret!=0){
printk("Unregister family %i\n",ret);

return;
}
}

module_init(gnKernel_init);
module_exit(gnKernel_exit);
MODULE_LICENSE("GPL");

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <poll.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <signal.h>

#include <linux/genetlink.h>

//Code based on http://people.ee.ethz.ch/~arkeller/linux/multi/kernel_user_space_howto-3.html

/* Generic macros for dealing with netlink sockets. Might be duplicated
 * elsewhere. It is recommended that commercial grade applications use
 * libnl or libnetlink and use the interfaces provided by the library
 */
#define GENLMSG_DATA(glh) ((void *)(NLMSG_DATA(glh) + GENL_HDRLEN))
#define GENLMSG_PAYLOAD(glh) (NLMSG_PAYLOAD(glh, 0) - GENL_HDRLEN)
#define NLA_DATA(na) ((void *)((char*)(na) + NLA_HDRLEN))

#define MESSAGE_TO_KERNEL "Hello World!"

//Variables used for netlink
intnl_fd;//netlink socket's file descriptor
structsockaddr_nlnl_address;//netlink socket address
intnl_family_id;//The family ID resolved by the netlink controller for this userspace program
intnl_rxtx_length;//Number of bytes sent or received via send() or recv()
structnlattr*nl_na;//pointer to netlink attributes structure within the payload 
struct{//memory for netlink request and response messages - headers are included
structnlmsghdrn;
structgenlmsghdrg;
charbuf[256];
}nl_request_msg,nl_response_msg;


intmain(void){
//Step 1: Open the socket. Note that protocol = NETLINK_GENERIC
nl_fd=socket(AF_NETLINK,SOCK_RAW,NETLINK_GENERIC);
if(nl_fd<0){
perror("socket()");
return-1;
}

//Step 2: Bind the socket.
memset(&nl_address,0,sizeof(nl_address));
nl_address.nl_family=AF_NETLINK;
nl_address.nl_groups=0;

if(bind(nl_fd,(structsockaddr*)&nl_address,sizeof(nl_address))<0){
perror("bind()");
close(nl_fd);
return-1;
}

//Step 3. Resolve the family ID corresponding to the string "CONTROL_EXMPL"
//Populate the netlink header
nl_request_msg.n.nlmsg_type=GENL_ID_CTRL;
nl_request_msg.n.nlmsg_flags=NLM_F_REQUEST;
nl_request_msg.n.nlmsg_seq=0;
nl_request_msg.n.nlmsg_pid=getpid();
nl_request_msg.n.nlmsg_len=NLMSG_LENGTH(GENL_HDRLEN);
//Populate the payload's "family header" : which in our case is genlmsghdr
nl_request_msg.g.cmd=CTRL_CMD_GETFAMILY;
nl_request_msg.g.version=0x1;
//Populate the payload's "netlink attributes"
nl_na=(structnlattr*)GENLMSG_DATA(&nl_request_msg);
nl_na->nla_type=CTRL_ATTR_FAMILY_NAME;
nl_na->nla_len=strlen("CONTROL_EXMPL")+1+NLA_HDRLEN;
strcpy(NLA_DATA(nl_na),"CONTROL_EXMPL");//Family name length can be upto 16 chars including \0

nl_request_msg.n.nlmsg_len+=NLMSG_ALIGN(nl_na->nla_len);

memset(&nl_address,0,sizeof(nl_address));
nl_address.nl_family=AF_NETLINK;

//Send the family ID request message to the netlink controller
nl_rxtx_length=sendto(nl_fd,(char*)&nl_request_msg,nl_request_msg.n.nlmsg_len,
0,(structsockaddr*)&nl_address,sizeof(nl_address));
if(nl_rxtx_length!=nl_request_msg.n.nlmsg_len){
perror("sendto()");
close(nl_fd);
return-1;
}

//Wait for the response message
nl_rxtx_length=recv(nl_fd,&nl_response_msg,sizeof(nl_response_msg),0);
if(nl_rxtx_length<0){
perror("recv()");
return-1;
}

//Validate response message
if(!NLMSG_OK((&nl_response_msg.n),nl_rxtx_length)){
fprintf(stderr,"family ID request : invalid message\n");
return-1;
}
if(nl_response_msg.n.nlmsg_type==NLMSG_ERROR){//error
fprintf(stderr,"family ID request : receive error\n");
return-1;
}

//Extract family ID
nl_na=(structnlattr*)GENLMSG_DATA(&nl_response_msg);
nl_na=(structnlattr*)((char*)nl_na+NLA_ALIGN(nl_na->nla_len));
if(nl_na->nla_type==CTRL_ATTR_FAMILY_ID){
nl_family_id=*(__u16*)NLA_DATA(nl_na);
}

//Step 4. Send own custom message
memset(&nl_request_msg,0,sizeof(nl_request_msg));
memset(&nl_response_msg,0,sizeof(nl_response_msg));

nl_request_msg.n.nlmsg_len=NLMSG_LENGTH(GENL_HDRLEN);
nl_request_msg.n.nlmsg_type=nl_family_id;
nl_request_msg.n.nlmsg_flags=NLM_F_REQUEST;
nl_request_msg.n.nlmsg_seq=60;
nl_request_msg.n.nlmsg_pid=getpid();
nl_request_msg.g.cmd=1;//corresponds to DOC_EXMPL_C_ECHO;

nl_na=(structnlattr*)GENLMSG_DATA(&nl_request_msg);
nl_na->nla_type=1;// corresponds to DOC_EXMPL_A_MSG
nl_na->nla_len=sizeof(MESSAGE_TO_KERNEL)+NLA_HDRLEN;//Message length
memcpy(NLA_DATA(nl_na),MESSAGE_TO_KERNEL,sizeof(MESSAGE_TO_KERNEL));
nl_request_msg.n.nlmsg_len+=NLMSG_ALIGN(nl_na->nla_len);

memset(&nl_address,0,sizeof(nl_address));
nl_address.nl_family=AF_NETLINK;

//Send the custom message
nl_rxtx_length=sendto(nl_fd,(char*)&nl_request_msg,nl_request_msg.n.nlmsg_len,
0,(structsockaddr*)&nl_address,sizeof(nl_address));
if(nl_rxtx_length!=nl_request_msg.n.nlmsg_len){
perror("sendto()");
close(nl_fd);
return-1;
}
printf("Sent to kernel: %s\n",MESSAGE_TO_KERNEL);

//Receive reply from kernel
nl_rxtx_length=recv(nl_fd,&nl_response_msg,sizeof(nl_response_msg),0);
if(nl_rxtx_length<0){
perror("recv()");
return-1;
}

//Validate response message
if(nl_response_msg.n.nlmsg_type==NLMSG_ERROR){//Error
printf("Error while receiving reply from kernel: NACK Received\n");
close(nl_fd);
return-1;
}
if(nl_rxtx_length<0){
printf("Error while receiving reply from kernel\n");
close(nl_fd);
return-1;
}
if(!NLMSG_OK((&nl_response_msg.n),nl_rxtx_length)){
printf("Error while receiving reply from kernel: Invalid Message\n");
close(nl_fd);
return-1;
}

//Parse the reply message
nl_rxtx_length=GENLMSG_PAYLOAD(&nl_response_msg.n);
nl_na=(structnlattr*)GENLMSG_DATA(&nl_response_msg);
printf("Kernel replied: %s\n",(char*)NLA_DATA(nl_na));

//Step 5. Close the socket and quit
close(nl_fd);
return0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

obj-m += nl_kern.o
nl_kern-objs := kern/nl_kern.o

all: kernel-module-uninstall kernel-clean-ring-buffer kernel-build kernel-clean-temporary kernel-module-install user-build
 @tput setaf 3
 @echo "    done: all"
 @tput sgr0
clean: kernel-module-uninstall kernel-clean user-clean
 @tput setaf 3
 @echo "    done: clean"
 @tput sgr0



kernel-build:
 @tput setaf 1
 @echo "    kernel-build"
 @tput sgr0
 make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
kernel-clean:
 @tput setaf 1
 @echo "    kernel-clean"
 @tput sgr0
 make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
kernel-clean-temporary:
 @tput setaf 1
 @echo "    kernel-clean-temporary"
 @tput sgr0
 -rm -rf *.o *~ core .depend .*.cmd *.mod.c .tmp_versions
 -rm -rf kern/*.o kern/*~ kern/core kern/.depend kern/.*.cmd kern/*.mod.c kern/.tmp_versions
 -rm -rf Module.symvers modules.order
kernel-module-install:
 @tput setaf 1
 @echo "    kernel-module-install"
 @tput sgr0
 -sudo insmod nl_kern.ko
kernel-module-uninstall:
 @tput setaf 1
 @echo "    kernel-module-uninstall"
 @tput sgr0
 -sudo rmmod nl_kern
kernel-clean-ring-buffer:
 @tput setaf 1
 @echo "    kernel-clean-ring-buffer"
 @tput sgr0
 sudo dmesg -c > /dev/null



user-build:
 @tput setaf 1
 @echo "    user-build"
 @tput sgr0
 gcc user/nl_user.c -o nl_user.out
user-clean:
 @tput setaf 1
 @echo "    user-clean"
 @tput sgr0
 rm -rf *.out

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

#include <net/genetlink.h>
#include <linux/module.h>
#include <linux/kernel.h>

#include "genl_event.h"

//Code based on http://people.ee.ethz.ch/~arkeller/linux/multi/kernel_user_space_howto-3.html

staticstructgenl_familygenl_exmpl_event_family={
.id=GENL_ID_GENERATE,//Genetlink should generate an id
.hdrsize=0,
.name=GENL_EXMPL_EVENT_FAMILYNAME,//The name of this family, used by userspace application
.version=GENL_EXMPL_EVENT_VERSION,//Version number  
.maxattr=GENL_EXMPL_EVENT_A_MAX,
};

staticstructgenl_multicast_groupgenl_exmpl_event_group={
.name=GENL_EXMPL_EVENT_GROUPNAME,
};

uint8_tgenl_exmpl_event_init(void){
intrc;

//Step 01: Register the new family
rc=genl_register_family(&genl_exmpl_event_family);
if(rc!=0){
gotofailure;
}

//Step 02: Register group for the new family
//Referred: http://lxr.free-electrons.com/source/drivers/acpi/event.c?v=2.6.33#L254
rc=genl_register_mc_group(&genl_exmpl_event_family,&genl_exmpl_event_group);
if(rc!=0){
printk("Generic Netlink register group: %i",rc);
genl_unregister_family(&genl_exmpl_event_family);
gotofailure;
}

return0;
failure:
return-1;
}

voidgenl_exmpl_event_deinit(void){
intret;

//Unregister the family
ret=genl_unregister_family(&genl_exmpl_event_family);
if(ret!=0){
printk("Generic Netlink unregister family %i\n",ret);
}
}

intgenl_exmpl_event_send(u8*msg,intlen){
//Referred: http://lxr.free-electrons.com/source/drivers/acpi/event.c?v=2.6.33#L183
structsk_buff*skb;
intrc;
void*msg_head;

//Send a message back ti userspace
//Allocate some memory, since the size is not yet known use NLMSG_GOODSIZE
skb=genlmsg_new(NLMSG_GOODSIZE,GFP_KERNEL);
if(skb==NULL){
printk("Could not allocate skb\n");
return0;
}

//Create the message headers
/* arguments of genlmsg_put: 
       struct sk_buff *, 
       int (sending) pid, 
       int sequence number, 
       struct genl_family *, 
       int flags, 
       u8 command index (why do we need this?)
    */
msg_head=genlmsg_put(skb,0,0,&genl_exmpl_event_family,0,GENL_EXMPL_EVENT_C_DO);
if(msg_head==NULL){
rc=-ENOMEM;
printk("genlmsg_put() returned error\n");
return0;
}

//Add a GENL_EXMPL_EVENT_A_MSG attribute (actual value to be sent)
rc=nla_put(skb,GENL_EXMPL_EVENT_A_MSG,len,msg);
if(rc!=0){
printk("nla_put() returned error\n");
return0;
}

//Finalize the message
genlmsg_end(skb,msg_head);

//Send the message
rc=genlmsg_multicast(skb,0,genl_exmpl_event_group.id,GFP_ATOMIC);
if(rc!=0){
//printk("genlmsg_multicast() returned error (Group ID: %d)\n", genl_exmpl_event_group.id);
return0;
}else{
printk("genlmsg_multicast() event message sent (Group ID: %d): %s\n",genl_exmpl_event_group.id,msg);
}
return0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

/* attributes (variables):
 * the index in this enum is used as a reference for the type,
 * userspace application has to indicate the corresponding type
 * the policy is used for security considerations 
 */
enum{
GENL_EXMPL_EVENT_A_UNSPEC,
GENL_EXMPL_EVENT_A_MSG,
__GENL_EXMPL_EVENT_A_MAX,
};
#define GENL_EXMPL_EVENT_A_MAX (__GENL_EXMPL_EVENT_A_MAX - 1)

/* commands: enumeration of all commands (functions), 
 * used by userspace application to identify command to be executed
 */
enum{
GENL_EXMPL_EVENT_C_UNSPEC,
GENL_EXMPL_EVENT_C_DO,
__GENL_EXMPL_EVENT_C_MAX,
};
#define GENL_EXMPL_EVENT_C_MAX (__GENL_EXMPL_EVENT_C_MAX - 1)

#define GENL_EXMPL_EVENT_VERSION 1
#define GENL_EXMPL_EVENT_FAMILYNAME "CONTROL_EXMPL"
#define GENL_EXMPL_EVENT_GROUPNAME "EXMPL_GRP"

uint8_tgenl_exmpl_event_init(void);
voidgenl_exmpl_event_deinit(void);
intgenl_exmpl_event_send(u8*msg,intlen);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

#include <linux/kernel.h>
#include <linux/module.h>
#include <net/genetlink.h>
#include <linux/ioport.h>

#include <linux/wait.h>
#include <linux/kthread.h>
#include <asm/io.h>
#include <linux/sched.h>
#include <linux/delay.h>

#include "genl_event.h"

structtask_struct*thr_ts1;

staticcharnl_string[50]="Hello";


intthread_func(void*data){
while(!kthread_should_stop()){
sprintf(nl_string,"Hello from kernel at jiffies %ld",jiffies);
genl_exmpl_event_send(nl_string,50);
set_current_state(TASK_INTERRUPTIBLE);
schedule_timeout(cputime_to_jiffies(secs_to_cputime(5)));//Do not schedule this thread again for the specified number of seconds
}
return0;
}

staticint__initgnKernel_init(void){
printk("Generic Netlink Example Module inserted.\n");

genl_exmpl_event_init();

thr_ts1=kthread_run(thread_func,NULL,"kthread1");

return0;
}

staticvoid__exitgnKernel_exit(void){
kthread_stop(thr_ts1);
genl_exmpl_event_deinit();

printk("Generic Netlink Example Module unloaded.\n");
}

module_init(gnKernel_init);
module_exit(gnKernel_exit);
MODULE_LICENSE("GPL");

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311

#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <unistd.h>
#include <poll.h>
#include <string.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <signal.h>

#include <linux/genetlink.h>



/* Code based on
 * http://people.ee.ethz.ch/~arkeller/linux/multi/kernel_user_space_howto-3.html
 * and
 * http://sourcecodebrowser.com/acpid/1.0.10/acpid_2src_2drivers_2netlink_8c_source.html
 * and
 * http://sourcecodebrowser.com/acpid/1.0.10/acpid_2include_2acpid_2driver_2netlink_8h.html
 */



/* Generic macros for dealing with netlink sockets. Might be duplicated
 * elsewhere. It is recommended that commercial grade applications use
 * libnl or libnetlink and use the interfaces provided by the library
 */
#define NLMSG_TAIL(nlh) ((struct nlattr *) (((void *) (nlh)) + NLMSG_ALIGN((nlh)->nlmsg_len)))
#define NLA_OK(rta,len) ((len) >= (int)sizeof(struct nlattr) && \
                (rta)->nla_len >= sizeof(struct nlattr) && \
                (rta)->nla_len <= (len))
#define NLA_NEXT(rta,attrlen)      ((attrlen) -= NLA_ALIGN((rta)->nla_len), \
                               (struct nlattr*)(((char*)(rta)) + NLA_ALIGN((rta)->nla_len)))
#define NLA_LENGTH(len)     (NLA_ALIGN(sizeof(struct nlattr)) + (len))
#define NLA_SPACE(len)      NLA_ALIGN(NLA_LENGTH(len))
#define NLA_DATA(rta)   ((void*)(((char*)(rta)) + NLA_LENGTH(0)))
#define NLA_PAYLOAD(rta) ((int)((rta)->nla_len) - NLA_LENGTH(0))
#define GENLMSG_DATA(glh) ((void *)(NLMSG_DATA(glh) + GENL_HDRLEN))
#define GENLMSG_PAYLOAD(glh) (NLMSG_PAYLOAD(glh, 0) - GENL_HDRLEN)
#define GENL_MAX_FAM_OPS   256
#define GENL_MAX_FAM_GRPS   256


//Variables used for netlink
intnl_fd;//netlink socket's file descriptor
structsockaddr_nlnl_address;//netlink socket address
intnl_family_id;//The family ID resolved by the netlink controller for this userspace program
intnl_group_id;
intnl_rxtx_length;//Number of bytes sent or received via send() or recv()
structnlattr*nl_na;//pointer to netlink attributes structure within the payload 
struct{//memory for netlink request and response messages - headers are included
structnlmsghdrn;
structgenlmsghdrg;
charbuf[256];
}nl_request_msg,nl_response_msg;
unsignedlongnl_sequence_number=0;
staticconstchar*nl_family_name="CONTROL_EXMPL";
staticconstchar*nl_group_name="EXMPL_GRP";
#define GENL_EXMPL_EVENT_VERSION 1



//Implementation of common netlink related methods: open, close, send, receive
intnetlink_open(int*fd,unsignedlong*seq_init,intprotocol,intgroups){
structsockaddr_nlnladdr;//netlink socket address
socklen_tlen;

*fd=socket(AF_NETLINK,SOCK_RAW,protocol);
if(*fd<0){
return-1;
}
memset(&nladdr,0,sizeof(nladdr));
nladdr.nl_family=AF_NETLINK;
nladdr.nl_groups=groups;


if(bind(*fd,(structsockaddr*)&nladdr,sizeof(nladdr))<0){
gotofail;
}
len=sizeof(nladdr);
if(getsockname(*fd,(structsockaddr*)&nladdr,&len)<0){
gotofail;
}

*seq_init=time(NULL);

return0;
fail:
close(*fd);
return-1;
}

intnetlink_send(intfd,unsignedlong*seq_num,structnlmsghdr*n,pid_tpeer,intgroups){
structsockaddr_nlnladdr={.nl_family=AF_NETLINK,.nl_pid=peer,.nl_groups=groups};
n->nlmsg_seq=++(*seq_num);
returnsendto(fd,n,n->nlmsg_len,0,(structsockaddr*)&nladdr,sizeof(nladdr));
}

intnetlink_recv(intfd,structnlmsghdr*n,pid_t*peer){
structsockaddr_nlnladdr;
socklen_tlen=sizeof(nladdr);
intret=recvfrom(fd,n,n->nlmsg_len,0,(structsockaddr*)&nladdr,&len);
*peer=nladdr.nl_pid;
returnret;
}


intnetlink_wait(intfd,unsignedlong*seq_num,structnlmsghdr*n,pid_tpeer){
intlen=n->nlmsg_len;

for(;;){
pid_tsender;
structnlmsghdr*h;
n->nlmsg_len=len;
intret=netlink_recv(fd,n,&sender);
if(ret<0){
fprintf(stderr,"%s() | Error\n",__func__);
continue;
}
if(sender!=peer){
fprintf(stderr,"%s() | Error: Source PID mismatch\n",__func__);
continue;
}
for(h=n;NLMSG_OK(h,ret);h=NLMSG_NEXT(h,ret)){
if(h->nlmsg_pid!=getpid()){
fprintf(stderr,"%s() | Error: Destination PID mismatch\n",__func__);
continue;
}

if(h->nlmsg_type==NLMSG_ERROR){
fprintf(stderr,"%s() | Error: Message receive error\n",__func__);
return-1;
}
memcpy(n,h,h->nlmsg_len);
return0;
}
}
}

voidnetlink_close(intfd){
close(fd);
}

//Implementation of common netlink message parsing methods
intnetlink_attr_attach(structnlmsghdr*n,intmax,inttype,constvoid*data,intalen){
intlen=NLA_LENGTH(alen);
structnlattr*nla;

if(NLMSG_ALIGN(n->nlmsg_len)+NLA_ALIGN(len)>max){
return-1;
}

nla=NLMSG_TAIL(n);
nla->nla_type=type;
nla->nla_len=len;
memcpy(NLA_DATA(nla),data,alen);
n->nlmsg_len=NLMSG_ALIGN(n->nlmsg_len)+NLA_ALIGN(len);
return0;
}

intnetlink_attr_parse(structnlattr*table[],intmax,structnlattr*src,intlen){
memset(table,0,sizeof(structnlattr*)*(max+1));
while(NLA_OK(src,len)){
if(src->nla_type<=max)
table[src->nla_type]=src;
src=NLA_NEXT(src,len);
}
return0;
}

staticintnetlink_verify_group(structnlattr*attr,int*group,constchar*expected_group_name){
constchar*name;
if(attr==NULL){
return-1;
}

structnlattr*attrs[CTRL_ATTR_MCAST_GRP_MAX+1];
netlink_attr_parse(attrs,CTRL_ATTR_MCAST_GRP_MAX,NLA_DATA(attr),attr->nla_len-NLA_HDRLEN);

name=NLA_DATA(attrs[CTRL_ATTR_MCAST_GRP_NAME]);
if(strcmp(name,expected_group_name)){
return-1;
}

*group=*(__u32*)(NLA_DATA(attrs[CTRL_ATTR_MCAST_GRP_ID]));
return0;
}

intnetlink_wait_for_event(intfd,char*received_msg,intmax){
charbuffer[256];
inti;
intret;
structnlmsghdr*n=(structnlmsghdr*)&buffer;
structnlmsghdr*h;
pid_tsender;

n->nlmsg_len=256;


ret=netlink_recv(fd,n,&sender);

if(ret<0){
return-1;
}

i=0;
for(h=n;NLMSG_OK(h,ret)&&i<max;h=NLMSG_NEXT(h,ret),++i){
if(h->nlmsg_type==NLMSG_ERROR){
return-1;
}
printf("Event received from Kernel: %s\n",(char*)NLA_DATA(((structnlattr*)GENLMSG_DATA(h))));
}

returni;
}

intmain(void){
intreturn_code;
//Step 1: Open & Bind the socket. Note that protocol = NETLINK_GENERIC
return_code=netlink_open(&nl_fd,&nl_sequence_number,NETLINK_GENERIC,0);
if(return_code<0){
fprintf(stderr,"Error: Socket could not be created\n");
return-1;
}
printf("%s() | Socket Opened\n",__func__);

//Step 2. Resolve the family ID corresponding to the string "EXMPL_EVENT"
{
charbuffer[256];
structnlmsghdr*nlmsg=(structnlmsghdr*)&buffer;
structnlattr*attrs[CTRL_ATTR_MAX+1];

nlmsg->nlmsg_len=NLMSG_LENGTH(GENL_HDRLEN);
nlmsg->nlmsg_flags=NLM_F_REQUEST|NLM_F_ACK;
nlmsg->nlmsg_type=GENL_ID_CTRL;
nlmsg->nlmsg_pid=getpid();

structgenlmsghdr*ghdr=NLMSG_DATA(nlmsg);
ghdr->cmd=CTRL_CMD_GETFAMILY;

netlink_attr_attach(nlmsg,128,CTRL_ATTR_FAMILY_NAME,nl_family_name,strlen(nl_family_name)+1);

if(netlink_send(nl_fd,&nl_sequence_number,nlmsg,0,0)<0){
fprintf(stderr,"%s() | Error: sending family ID request message\n",__func__);
netlink_close(nl_fd);
return-1;
}
printf("%s() | Family Request Sent\n",__func__);

nlmsg->nlmsg_len=256;
//Wait for the response message
if(netlink_wait(nl_fd,&nl_sequence_number,nlmsg,0)<0){
fprintf(stderr,"Error: receiving family ID request message\n",__func__);
netlink_close(nl_fd);
return-1;
}

//Validate response message
if(nlmsg->nlmsg_type!=GENL_ID_CTRL){
fprintf(stderr,"%s() | Error: family ID request - invalid message\n",__func__);
netlink_close(nl_fd);
return-1;
}
ghdr=NLMSG_DATA(nlmsg);
if(ghdr->cmd!=CTRL_CMD_NEWFAMILY){
fprintf(stderr,"%s() | Error: family ID request - invalid message\n",__func__);
netlink_close(nl_fd);
return-1;
}
if(nlmsg->nlmsg_len<NLMSG_LENGTH(GENL_HDRLEN)){
fprintf(stderr,"%s() | Error: family ID request - invalid message\n",__func__);
netlink_close(nl_fd);
return-1;
}


netlink_attr_parse(attrs,CTRL_ATTR_MAX,NLMSG_DATA(nlmsg)+GENL_HDRLEN,NLMSG_PAYLOAD(nlmsg,GENL_HDRLEN));

if(attrs[CTRL_ATTR_FAMILY_ID]){
nl_family_id=*(__u32*)(NLA_DATA(attrs[CTRL_ATTR_FAMILY_ID]));
printf("%s() | Family ID resolved for \"%s\": %d\n",__func__,nl_family_name,nl_family_id);
}

if(attrs[CTRL_ATTR_MCAST_GROUPS]){
inti;
structnlattr*attrs2[GENL_MAX_FAM_GRPS+1];
netlink_attr_parse(attrs2,GENL_MAX_FAM_GRPS,NLA_DATA(attrs[CTRL_ATTR_MCAST_GROUPS]),attrs[CTRL_ATTR_MCAST_GROUPS]->nla_len-NLA_HDRLEN);

for(i=0;i<GENL_MAX_FAM_GRPS;i++){
if(netlink_verify_group(attrs2[i],&nl_group_id,nl_group_name)==0){
printf("%s() | Group ID resolved for \"%s\": %d\n",__func__,nl_group_name,nl_group_id);
}
}
}

//Step 3. Close and Reopen Socket for specified group
netlink_close(nl_fd);
if(netlink_open(&nl_fd,&nl_sequence_number,NETLINK_GENERIC,nl_group_id?(1<<(nl_group_id-1)):0)){
fprintf(stderr,"Error: Socket could not be re-created\n");
return-1;
}

netlink_wait_for_event(nl_fd,NULL,10);
}
netlink_close(nl_fd);
printf("%s() | Socket Closed\n",__func__);
return0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

EXTRA_CFLAGS+= -I./kern

obj-m+= nl_kern.o
nl_kern-objs:= kern/main.o kern/genl_event.o

all:kernel-module-uninstall kernel-clean-ring-buffer kernel-build kernel-clean-temporary kernel-module-install user-build
 @tput setaf 3
 @echo "    done: all"
 @tput sgr0
clean:kernel-module-uninstall kernel-clean user-clean
 @tput setaf 3
 @echo "    done: clean"
 @tput sgr0



kernel-build:
 @tput setaf 1
 @echo "    kernel-build"
 @tput sgr0
 make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
kernel-clean:
 @tput setaf 1
 @echo "    kernel-clean"
 @tput sgr0
 make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
kernel-clean-temporary:
 @tput setaf 1
 @echo "    kernel-clean-temporary"
 @tput sgr0
 -rm -rf *.o *~ core .depend .*.cmd *.mod.c .tmp_versions
 -rm -rf kern/*.o kern/*~ kern/core kern/.depend kern/.*.cmd kern/*.mod.c kern/.tmp_versions
 -rm -rf Module.symvers modules.order
kernel-module-install:
 @tput setaf 1
 @echo "    kernel-module-install"
 @tput sgr0
 -sudo insmod nl_kern.ko
kernel-module-uninstall:
 @tput setaf 1
 @echo "    kernel-module-uninstall"
 @tput sgr0
 -sudo rmmod nl_kern
kernel-clean-ring-buffer:
 @tput setaf 1
 @echo "    kernel-clean-ring-buffer"
 @tput sgr0
 sudo dmesg -c > /dev/null



user-build:
 @tput setaf 1
 @echo "    user-build"
 @tput sgr0
 gcc user/main.c -o nl_user.out
user-clean:
 @tput setaf 1
 @echo "    user-clean"
 @tput sgr0
 rm -rf *.out