nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 #include <string.h>
2 #include <stdlib.h>
3 #include <pthread.h>
4  
5 #include "linkedlist.h"
6  
7 pthread_mutex_t clist_mutex = PTHREAD_MUTEX_INITIALIZER;
8  
9 struct clist *search_status(struct clist *c, int desired_status)
10 {
11 if (!c) return NULL;
12  
13 pthread_mutex_lock(&clist_mutex);
14 struct clist *first = c;
15  
16 do {
17 if (c->status == desired_status) {
18 pthread_mutex_unlock(&clist_mutex);
19 return c;
20 }
21 c = c->next;
22 } while (c != first);
23  
24 pthread_mutex_unlock(&clist_mutex);
25 return NULL;
26 }
27  
28 struct clistwidsclient *search_status_widsclient(struct clistwidsclient *c, int desired_status, int desired_channel)
29 {
30 if (!c) return NULL;
31  
32 pthread_mutex_lock(&clist_mutex);
33 struct clistwidsclient *first = c;
34  
35 do {
36 if ((c->status == desired_status) && ((c->bssid->channel == desired_channel) || (desired_channel = -1))) {
37 pthread_mutex_unlock(&clist_mutex);
38 return c;
39 }
40 c = c->next;
41 } while (c != first);
42  
43 pthread_mutex_unlock(&clist_mutex);
44 return NULL;
45 }
46  
47 struct clist *search_data(struct clist *c, unsigned char *desired_data, int data_len)
48 {
49 if (!c) return NULL;
50  
51 pthread_mutex_lock(&clist_mutex);
52 struct clist *first = c;
53  
54 do {
55 if (data_len <= c->data_len) {
56 if (! (memcmp(c->data, desired_data, data_len))) {
57 pthread_mutex_unlock(&clist_mutex);
58 return c;
59 }
60 }
61 c = c->next;
62 } while (c != first);
63  
64 pthread_mutex_unlock(&clist_mutex);
65 return NULL;
66 }
67  
68 struct clistwidsap *search_bssid(struct clistwidsap *c, struct ether_addr desired_bssid)
69 {
70 if (!c) return NULL;
71  
72 pthread_mutex_lock(&clist_mutex);
73 struct clistwidsap *first = c;
74  
75 do {
76 if (MAC_MATCHES(c->bssid, desired_bssid)) {
77 pthread_mutex_unlock(&clist_mutex);
78 return c;
79 }
80 c = c->next;
81 } while (c != first);
82  
83 pthread_mutex_unlock(&clist_mutex);
84 return NULL;
85 }
86  
87 struct clistwidsclient *search_client(struct clistwidsclient *c, struct ether_addr mac)
88 {
89 if (!c) return NULL;
90  
91 pthread_mutex_lock(&clist_mutex);
92 struct clistwidsclient *first = c;
93  
94 do {
95 if (MAC_MATCHES(c->mac, mac)) {
96 pthread_mutex_unlock(&clist_mutex);
97 return c;
98 }
99 c = c->next;
100 } while (c != first);
101  
102 pthread_mutex_unlock(&clist_mutex);
103 return NULL;
104 }
105  
106 struct clistauthdos *search_ap(struct clistauthdos *c, struct ether_addr ap)
107 {
108 if (!c) return NULL;
109  
110 pthread_mutex_lock(&clist_mutex);
111 struct clistauthdos *first = c;
112  
113 do {
114 if (MAC_MATCHES(c->ap, ap)) {
115 pthread_mutex_unlock(&clist_mutex);
116 return c;
117 }
118 c = c->next;
119 } while (c != first);
120  
121 pthread_mutex_unlock(&clist_mutex);
122 return NULL;
123 }
124  
125 struct clist *add_to_clist(struct clist *c, unsigned char *data, int status, int data_len)
126 {
127 pthread_mutex_lock(&clist_mutex);
128  
129 struct clist *new_item = (struct clist *) malloc(sizeof(struct clist));
130 new_item->data = malloc(data_len);
131 new_item->data_len = data_len;
132  
133 if (c) {
134 new_item->next = c->next;
135 c->next = new_item;
136 } else {
137 new_item->next = new_item;
138 }
139  
140 memcpy(new_item->data, data, data_len);
141 new_item->status = status;
142  
143 pthread_mutex_unlock(&clist_mutex);
144 return new_item;
145 }
146  
147 struct clistwidsap *add_to_clistwidsap(struct clistwidsap *c, struct ether_addr bssid, int channel, uint16_t capa, char *ssid)
148 {
149 pthread_mutex_lock(&clist_mutex);
150  
151 struct clistwidsap *new_item = (struct clistwidsap *) malloc(sizeof(struct clistwidsap));
152 new_item->bssid = bssid;
153  
154 if (c) {
155 new_item->next = c->next;
156 c->next = new_item;
157 } else {
158 new_item->next = new_item;
159 }
160  
161 new_item->channel = channel;
162 new_item->capa = capa;
163 new_item->ssid = malloc(strlen(ssid) + 1);
164 strcpy(new_item->ssid, ssid);
165  
166 pthread_mutex_unlock(&clist_mutex);
167 return new_item;
168 }
169  
170 struct clistwidsclient *add_to_clistwidsclient(struct clistwidsclient *c, struct ether_addr mac, int status, unsigned char *data, int data_len, uint16_t sequence, struct clistwidsap *bssid)
171 {
172 pthread_mutex_lock(&clist_mutex);
173  
174 struct clistwidsclient *new_item = (struct clistwidsclient *) malloc(sizeof(struct clistwidsclient));
175 new_item->mac = mac;
176 new_item->data = malloc(data_len);
177  
178 if (c) {
179 new_item->next = c->next;
180 c->next = new_item;
181 } else {
182 new_item->next = new_item;
183 }
184  
185 memcpy(new_item->data, data, data_len);
186 new_item->status = status;
187 new_item->data_len = data_len;
188 new_item->bssid = bssid;
189 new_item->retries = 0;
190 new_item->seq = sequence;
191  
192 pthread_mutex_unlock(&clist_mutex);
193 return new_item;
194 }
195  
196 struct clistauthdos *add_to_clistauthdos(struct clistauthdos *c, struct ether_addr ap, unsigned char status, unsigned int responses, unsigned int missing)
197 {
198 pthread_mutex_lock(&clist_mutex);
199  
200 struct clistauthdos *new_item = (struct clistauthdos *) malloc(sizeof(struct clistauthdos));
201 new_item->ap = ap;
202  
203 if (c) {
204 new_item->next = c->next;
205 c->next = new_item;
206 } else {
207 new_item->next = new_item;
208 }
209  
210 new_item->status = status;
211 new_item->responses = responses;
212 new_item->missing = missing;
213  
214 pthread_mutex_unlock(&clist_mutex);
215 return new_item;
216 }
217  
218 struct clistauthdos *search_authdos_status(struct clistauthdos *c, int desired_status) {
219 if (!c) return NULL;
220  
221 pthread_mutex_lock(&clist_mutex);
222 struct clistauthdos *first = c;
223  
224 do {
225 if (c->status == desired_status) {
226 pthread_mutex_unlock(&clist_mutex);
227 return c;
228 }
229 c = c->next;
230 } while (c != first);
231  
232 pthread_mutex_unlock(&clist_mutex);
233 return NULL;
234 }
235  
236 struct clistwidsap *search_bssid_on_channel(struct clistwidsap *c, int desired_channel) {
237 if (!c) return NULL;
238  
239 pthread_mutex_lock(&clist_mutex);
240 struct clistwidsap *first = c;
241  
242 do {
243 if (desired_channel == c->channel) {
244 pthread_mutex_unlock(&clist_mutex);
245 return c;
246 }
247 c = c->next;
248 } while (c != first);
249  
250 pthread_mutex_unlock(&clist_mutex);
251 return NULL;
252 }
253  
254 struct clistwidsap *shuffle_widsaps(struct clistwidsap *c) {
255 int i, rnd = random() % SHUFFLE_DISTANCE;
256 struct clistwidsap *r = c;
257  
258 for(i=0; i<rnd; i++) r = r->next;
259  
260 return r;
261 }
262  
263 struct clistwidsclient *shuffle_widsclients(struct clistwidsclient *c) {
264 int i, rnd = random() % SHUFFLE_DISTANCE;
265 struct clistwidsclient *r = c;
266  
267 for(i=0; i<rnd; i++) r = r->next;
268  
269 return r;
270 }