1 /**
2 * Author......: See docs/credits.txt
3 * License.....: MIT
4 */
5
6 #include "common.h"
7 #include "types.h"
8 #include "thread.h"
9 #include "event.h"
10
event_call(const u32 id,hashcat_ctx_t * hashcat_ctx,const void * buf,const size_t len)11 void event_call (const u32 id, hashcat_ctx_t *hashcat_ctx, const void *buf, const size_t len)
12 {
13 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
14
15 bool is_log = false;
16
17 switch (id)
18 {
19 case EVENT_LOG_INFO: is_log = true; break;
20 case EVENT_LOG_WARNING: is_log = true; break;
21 case EVENT_LOG_ERROR: is_log = true; break;
22 case EVENT_LOG_ADVICE: is_log = true; break;
23 }
24
25 if (is_log == false)
26 {
27 hc_thread_mutex_lock (event_ctx->mux_event);
28 }
29
30 hashcat_ctx->event (id, hashcat_ctx, buf, len);
31
32 if (is_log == false)
33 {
34 hc_thread_mutex_unlock (event_ctx->mux_event);
35 }
36
37 // add more back logs in case user wants to access them
38
39 if (is_log == false)
40 {
41 for (int i = MAX_OLD_EVENTS - 1; i >= 1; i--)
42 {
43 memcpy (event_ctx->old_buf[i], event_ctx->old_buf[i - 1], event_ctx->old_len[i - 1]);
44
45 event_ctx->old_len[i] = event_ctx->old_len[i - 1];
46 }
47
48 size_t copy_len = 0;
49
50 if (buf)
51 {
52 // truncate the whole buffer if needed (such that it fits into the old_buf):
53
54 const size_t max_buf_len = sizeof (event_ctx->old_buf[0]);
55
56 copy_len = MIN (len, max_buf_len - 1);
57
58 memcpy (event_ctx->old_buf[0], buf, copy_len);
59 }
60
61 event_ctx->old_len[0] = copy_len;
62 }
63 }
64
65 __attribute__ ((format (printf, 1, 0)))
event_log(const char * fmt,va_list ap,char * s,const size_t sz)66 static int event_log (const char *fmt, va_list ap, char *s, const size_t sz)
67 {
68 size_t length;
69
70 length = vsnprintf (s, sz, fmt, ap);
71 length = MIN (length, sz);
72
73 s[length] = 0;
74
75 return (int) length;
76 }
77
event_log_advice_nn(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)78 size_t event_log_advice_nn (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
79 {
80 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
81
82 if (fmt == NULL)
83 {
84 event_ctx->msg_buf[0] = 0;
85
86 event_ctx->msg_len = 0;
87 }
88 else
89 {
90 va_list ap;
91
92 va_start (ap, fmt);
93
94 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
95
96 va_end (ap);
97 }
98
99 event_ctx->msg_newline = false;
100
101 event_call (EVENT_LOG_ADVICE, hashcat_ctx, NULL, 0);
102
103 return event_ctx->msg_len;
104 }
105
event_log_info_nn(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)106 size_t event_log_info_nn (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
107 {
108 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
109
110 if (fmt == NULL)
111 {
112 event_ctx->msg_buf[0] = 0;
113
114 event_ctx->msg_len = 0;
115 }
116 else
117 {
118 va_list ap;
119
120 va_start (ap, fmt);
121
122 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
123
124 va_end (ap);
125 }
126
127 event_ctx->msg_newline = false;
128
129 event_call (EVENT_LOG_INFO, hashcat_ctx, NULL, 0);
130
131 return event_ctx->msg_len;
132 }
133
event_log_warning_nn(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)134 size_t event_log_warning_nn (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
135 {
136 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
137
138 if (fmt == NULL)
139 {
140 event_ctx->msg_buf[0] = 0;
141
142 event_ctx->msg_len = 0;
143 }
144 else
145 {
146 va_list ap;
147
148 va_start (ap, fmt);
149
150 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
151
152 va_end (ap);
153 }
154
155 event_ctx->msg_newline = false;
156
157 event_call (EVENT_LOG_WARNING, hashcat_ctx, NULL, 0);
158
159 return event_ctx->msg_len;
160 }
161
event_log_error_nn(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)162 size_t event_log_error_nn (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
163 {
164 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
165
166 if (fmt == NULL)
167 {
168 event_ctx->msg_buf[0] = 0;
169
170 event_ctx->msg_len = 0;
171 }
172 else
173 {
174 va_list ap;
175
176 va_start (ap, fmt);
177
178 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
179
180 va_end (ap);
181 }
182
183 event_ctx->msg_newline = false;
184
185 event_call (EVENT_LOG_ERROR, hashcat_ctx, NULL, 0);
186
187 return event_ctx->msg_len;
188 }
189
event_log_advice(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)190 size_t event_log_advice (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
191 {
192 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
193
194 if (fmt == NULL)
195 {
196 event_ctx->msg_buf[0] = 0;
197
198 event_ctx->msg_len = 0;
199 }
200 else
201 {
202 va_list ap;
203
204 va_start (ap, fmt);
205
206 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
207
208 va_end (ap);
209 }
210
211 event_ctx->msg_newline = true;
212
213 event_call (EVENT_LOG_ADVICE, hashcat_ctx, NULL, 0);
214
215 return event_ctx->msg_len;
216 }
217
event_log_info(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)218 size_t event_log_info (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
219 {
220 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
221
222 if (fmt == NULL)
223 {
224 event_ctx->msg_buf[0] = 0;
225
226 event_ctx->msg_len = 0;
227 }
228 else
229 {
230 va_list ap;
231
232 va_start (ap, fmt);
233
234 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
235
236 va_end (ap);
237 }
238
239 event_ctx->msg_newline = true;
240
241 event_call (EVENT_LOG_INFO, hashcat_ctx, NULL, 0);
242
243 return event_ctx->msg_len;
244 }
245
event_log_warning(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)246 size_t event_log_warning (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
247 {
248 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
249
250 if (fmt == NULL)
251 {
252 event_ctx->msg_buf[0] = 0;
253
254 event_ctx->msg_len = 0;
255 }
256 else
257 {
258 va_list ap;
259
260 va_start (ap, fmt);
261
262 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
263
264 va_end (ap);
265 }
266
267 event_ctx->msg_newline = true;
268
269 event_call (EVENT_LOG_WARNING, hashcat_ctx, NULL, 0);
270
271 return event_ctx->msg_len;
272 }
273
event_log_error(hashcat_ctx_t * hashcat_ctx,const char * fmt,...)274 size_t event_log_error (hashcat_ctx_t *hashcat_ctx, const char *fmt, ...)
275 {
276 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
277
278 if (fmt == NULL)
279 {
280 event_ctx->msg_buf[0] = 0;
281
282 event_ctx->msg_len = 0;
283 }
284 else
285 {
286 va_list ap;
287
288 va_start (ap, fmt);
289
290 event_ctx->msg_len = event_log (fmt, ap, event_ctx->msg_buf, HCBUFSIZ_SMALL - 1);
291
292 va_end (ap);
293 }
294
295 event_ctx->msg_newline = true;
296
297 event_call (EVENT_LOG_ERROR, hashcat_ctx, NULL, 0);
298
299 return event_ctx->msg_len;
300 }
301
event_ctx_init(hashcat_ctx_t * hashcat_ctx)302 int event_ctx_init (hashcat_ctx_t *hashcat_ctx)
303 {
304 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
305
306 memset (event_ctx, 0, sizeof (event_ctx_t));
307
308 hc_thread_mutex_init (event_ctx->mux_event);
309
310 return 0;
311 }
312
event_ctx_destroy(hashcat_ctx_t * hashcat_ctx)313 void event_ctx_destroy (hashcat_ctx_t *hashcat_ctx)
314 {
315 event_ctx_t *event_ctx = hashcat_ctx->event_ctx;
316
317 hc_thread_mutex_delete (event_ctx->mux_event);
318 }
319