1a5fb1d1690d2314aa3046b3c824206a8982f346
[rahunas] / src / rh-task-memset.c
1 /**
2  * RahuNAS task memset implementation 
3  * Author: Neutron Soutmun <neo.neutron@gmail.com>
4  * Date:   2008-09-07
5  */
6
7 #include <stdlib.h>
8 #include <syslog.h>
9 #include <time.h>
10 #include "rahunasd.h"
11 #include "rh-radius.h"
12 #include "rh-task.h"
13 #include "rh-ipset.h"
14
15 /* Initialize */
16 static void init (void)
17 {
18   struct rahunas_member *members = NULL;
19   int size;
20
21   logmsg(RH_LOG_NORMAL, "Task MEMSET init..");  
22   map = (struct rahunas_map*)(rh_malloc(sizeof(struct rahunas_map)));
23
24   map->members = NULL;
25   map->size = 0;
26
27   if (get_header_from_set(map) < 0) {
28     syslog(LOG_ERR, "Could not fetch IPSET header");
29     exit(EXIT_FAILURE);
30   }
31
32   size = map->size == 0 ? MAX_MEMBERS : map->size;
33
34         members = 
35     (struct rahunas_member*)(rh_malloc(sizeof(struct rahunas_member)*size));
36
37         memset(members, 0, sizeof(struct rahunas_member)*size);
38
39         map->members = members;
40 }
41
42 /* Cleanup */
43 static void cleanup (void)
44 {
45   struct rahunas_member *members = NULL;
46         int i;
47   int end;
48
49   logmsg(RH_LOG_NORMAL, "Task MEMSET cleanup..");  
50
51   if (map) {
52     if (map->members) {
53       members = map->members;
54       end = map->size;
55     } else {
56       end = 0;
57     }  
58
59           for (i=0; i < end; i++) {
60                           rh_free_member(&members[i]);
61                 }
62
63                 rh_free(&(map->members));
64                 rh_free(&map);
65         }
66
67   return 0;
68 }
69
70
71 /* Start service task */
72 static int startservice (struct rahunas_map *map)
73 {
74   /* Do nothing or need to implement */
75 }
76
77 /* Stop service task */
78 static int stopservice  (struct rahunas_map *map)
79 {
80   /* Do nothing or need to implement */
81 }
82
83 /* Start session task */
84 static int startsess (struct rahunas_map *map, struct task_req *req)
85 {
86         struct rahunas_member *members = map->members;
87   uint32_t id = req->id;
88
89   members[id].flags = 1;
90   if (members[id].username && members[id].username != termstring)
91     free(members[id].username);
92
93   if (members[id].session_id && members[id].username != termstring)
94     free(members[id].session_id);
95
96   members[id].username   = strdup(req->username);
97   if (!members[id].username)
98     members[id].username = termstring;
99
100   members[id].session_id = strdup(req->session_id);
101   if (!members[id].session_id)
102     members[id].session_id = termstring;
103
104         time(&(members[id].session_start));
105   memcpy(&req->session_start, &members[id].session_start, sizeof(time_t));
106
107   memcpy(&members[id].mac_address, &(req->mac_address), ETH_ALEN);
108
109   memcpy(&members[id].session_timeout, &req->session_timeout, sizeof(time_t));
110   members[id].bandwidth_max_down = req->bandwidth_max_down;
111   members[id].bandwidth_max_up = req->bandwidth_max_up;
112  
113   DP("Session-Timeout %d", req->session_timeout);
114   DP("Bandwidth - Down: %lu, Up: %lu", req->bandwidth_max_down, 
115        req->bandwidth_max_up);
116
117   logmsg(RH_LOG_NORMAL, "Session Start, User: %s, IP: %s, "
118                         "Session ID: %s, MAC: %s",
119                         members[id].username, 
120                         idtoip(map, id), 
121                         members[id].session_id,
122                         mac_tostring(members[id].mac_address)); 
123   return 0;
124 }
125
126 /* Stop session task */
127 static int stopsess  (struct rahunas_map *map, struct task_req *req)
128 {
129         struct rahunas_member *members = map->members;
130   uint32_t id = req->id;
131   char cause[16] = "";
132   switch (req->req_opt) {
133     case RH_RADIUS_TERM_IDLE_TIMEOUT :
134       strcpy(cause, "idle timeout");
135       break;
136     case RH_RADIUS_TERM_USER_REQUEST :
137       strcpy(cause, "user request");
138       break;
139     case RH_RADIUS_TERM_NAS_REBOOT :
140       strcpy(cause, "nas reboot");
141       break;
142   }
143   if (!members[id].username)
144     members[id].username = termstring;
145
146   if (!members[id].session_id)
147     members[id].session_id = termstring;
148
149   logmsg(RH_LOG_NORMAL, "Session Stop (%s), User: %s, IP: %s, "
150                         "Session ID: %s, MAC: %s",
151                         cause,
152                         members[id].username, 
153                         idtoip(map, id), 
154                         members[id].session_id,
155                         mac_tostring(members[id].mac_address)); 
156
157   rh_free_member(&members[id]);   
158
159   return 0;
160  
161 }
162
163 /* Commit start session task */
164 static int commitstartsess (struct rahunas_map *map, struct task_req *req)
165 {
166   /* Do nothing or need to implement */
167 }
168
169 /* Commit stop session task */
170 static int commitstopsess  (struct rahunas_map *map, struct task_req *req)
171 {
172   /* Do nothing or need to implement */
173 }
174
175 /* Rollback start session task */
176 static int rollbackstartsess (struct rahunas_map *map, struct task_req *req)
177 {
178   /* Do nothing or need to implement */
179 }
180
181 /* Rollback stop session task */
182 static int rollbackstopsess  (struct rahunas_map *map, struct task_req *req)
183 {
184   /* Do nothing or need to implement */
185 }
186
187 static struct task task_memset = {
188   .taskname = "MEMSET",
189   .taskprio = 40,
190   .init = &init,
191   .cleanup = &cleanup,
192   .startservice = &startservice,
193   .stopservice = &stopservice,
194   .startsess = &startsess,
195   .stopsess = &stopsess,
196   .commitstartsess = &commitstartsess,
197   .commitstopsess = &commitstopsess,
198   .rollbackstartsess = &rollbackstartsess,
199   .rollbackstopsess = &rollbackstopsess,
200 };
201
202 void rh_task_memset_reg(void) {
203   task_register(&task_memset);
204 }