Line data Source code
1 : /*-
2 : * Copyright (c) 2011-2013 Baptiste Daroussin <bapt@FreeBSD.org>
3 : * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
4 : * Copyright (c) 2015 Matthew Seaman <matthew@FreeBSD.org>
5 : * All rights reserved.
6 : *
7 : * Redistribution and use in source and binary forms, with or without
8 : * modification, are permitted provided that the following conditions
9 : * are met:
10 : * 1. Redistributions of source code must retain the above copyright
11 : * notice, this list of conditions and the following disclaimer
12 : * in this position and unchanged.
13 : * 2. Redistributions in binary form must reproduce the above copyright
14 : * notice, this list of conditions and the following disclaimer in the
15 : * documentation and/or other materials provided with the distribution.
16 : *
17 : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
18 : * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 : * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
21 : * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 : * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 : */
28 :
29 : #include <errno.h>
30 : #include <string.h>
31 : #include <syslog.h>
32 :
33 : #define _WITH_DPRINTF
34 : #include "pkg.h"
35 : #include "private/pkg.h"
36 : #include "private/event.h"
37 :
38 : static pkg_event_cb _cb = NULL;
39 : static void *_data = NULL;
40 :
41 : static char *
42 0 : sbuf_json_escape(struct sbuf *buf, const char *str)
43 : {
44 0 : sbuf_clear(buf);
45 0 : while (str != NULL && *str != '\0') {
46 0 : if (*str == '"' || *str == '\\')
47 0 : sbuf_putc(buf, '\\');
48 0 : sbuf_putc(buf, *str);
49 0 : str++;
50 : }
51 0 : sbuf_finish(buf);
52 :
53 0 : return (sbuf_data(buf));
54 : }
55 :
56 : static void
57 938 : pipeevent(struct pkg_event *ev)
58 : {
59 : int i;
60 938 : struct pkg_dep *dep = NULL;
61 : struct sbuf *msg, *buf;
62 : struct pkg_event_conflict *cur_conflict;
63 938 : if (eventpipe < 0)
64 1876 : return;
65 :
66 0 : msg = sbuf_new_auto();
67 0 : buf = sbuf_new_auto();
68 :
69 0 : switch(ev->type) {
70 : case PKG_EVENT_ERRNO:
71 0 : sbuf_printf(msg, "{ \"type\": \"ERROR\", "
72 : "\"data\": {"
73 : "\"msg\": \"%s(%s): %s\","
74 : "\"errno\": %d}}",
75 : sbuf_json_escape(buf, ev->e_errno.func),
76 : sbuf_json_escape(buf, ev->e_errno.arg),
77 0 : sbuf_json_escape(buf, strerror(ev->e_errno.no)),
78 : ev->e_errno.no);
79 0 : break;
80 : case PKG_EVENT_ERROR:
81 0 : sbuf_printf(msg, "{ \"type\": \"ERROR\", "
82 : "\"data\": {\"msg\": \"%s\"}}",
83 0 : sbuf_json_escape(buf, ev->e_pkg_error.msg));
84 0 : break;
85 : case PKG_EVENT_NOTICE:
86 0 : sbuf_printf(msg, "{ \"type\": \"NOTICE\", "
87 : "\"data\": {\"msg\": \"%s\"}}",
88 0 : sbuf_json_escape(buf, ev->e_pkg_notice.msg));
89 0 : break;
90 : case PKG_EVENT_DEVELOPER_MODE:
91 0 : sbuf_printf(msg, "{ \"type\": \"ERROR\", "
92 : "\"data\": {\"msg\": \"DEVELOPER_MODE: %s\"}}",
93 0 : sbuf_json_escape(buf, ev->e_pkg_error.msg));
94 0 : break;
95 : case PKG_EVENT_UPDATE_ADD:
96 0 : sbuf_printf(msg, "{ \"type\": \"INFO_UPDATE_ADD\", "
97 : "\"data\": { "
98 : "\"fetched\": %d, "
99 : "\"total\": %d"
100 : "}}",
101 : ev->e_upd_add.done,
102 : ev->e_upd_add.total
103 : );
104 0 : break;
105 : case PKG_EVENT_UPDATE_REMOVE:
106 0 : sbuf_printf(msg, "{ \"type\": \"INFO_UPDATE_REMOVE\", "
107 : "\"data\": { "
108 : "\"fetched\": %d, "
109 : "\"total\": %d"
110 : "}}",
111 : ev->e_upd_remove.done,
112 : ev->e_upd_remove.total
113 : );
114 0 : break;
115 : case PKG_EVENT_FETCH_BEGIN:
116 0 : sbuf_printf(msg, "{ \"type\": \"INFO_FETCH_BEGIN\", "
117 : "\"data\": { "
118 : "\"url\": \"%s\" "
119 : "}}",
120 : sbuf_json_escape(buf, ev->e_fetching.url)
121 : );
122 0 : break;
123 : case PKG_EVENT_FETCH_FINISHED:
124 0 : sbuf_printf(msg, "{ \"type\": \"INFO_FETCH_FINISHED\", "
125 : "\"data\": { "
126 : "\"url\": \"%s\" "
127 : "}}",
128 : sbuf_json_escape(buf, ev->e_fetching.url)
129 : );
130 0 : break;
131 : case PKG_EVENT_INSTALL_BEGIN:
132 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_BEGIN\", "
133 : "\"data\": { "
134 : "\"pkgname\": \"%n\", "
135 : "\"pkgversion\": \"%v\""
136 : "}}", ev->e_install_begin.pkg, ev->e_install_begin.pkg);
137 0 : break;
138 : case PKG_EVENT_EXTRACT_BEGIN:
139 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_EXTRACT_BEGIN\", "
140 : "\"data\": { "
141 : "\"pkgname\": \"%n\", "
142 : "\"pkgversion\": \"%v\""
143 : "}}", ev->e_extract_begin.pkg, ev->e_extract_begin.pkg);
144 0 : break;
145 : case PKG_EVENT_EXTRACT_FINISHED:
146 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_EXTRACT_FINISHED\", "
147 : "\"data\": { "
148 : "\"pkgname\": \"%n\", "
149 : "\"pkgversion\": \"%v\""
150 : "}}", ev->e_extract_finished.pkg, ev->e_extract_finished.pkg);
151 0 : break;
152 : case PKG_EVENT_INSTALL_FINISHED:
153 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_INSTALL_FINISHED\", "
154 : "\"data\": { "
155 : "\"pkgname\": \"%n\", "
156 : "\"pkgversion\": \"%v\", "
157 : "\"message\": \"%S\""
158 : "}}",
159 : ev->e_install_finished.pkg,
160 : ev->e_install_finished.pkg,
161 0 : sbuf_json_escape(buf, ev->e_install_finished.pkg->message));
162 0 : break;
163 : case PKG_EVENT_INTEGRITYCHECK_BEGIN:
164 0 : sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_BEGIN\", "
165 : "\"data\": {}}");
166 0 : break;
167 : case PKG_EVENT_INTEGRITYCHECK_CONFLICT:
168 0 : sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_CONFLICT\","
169 : "\"data\": { "
170 : "\"pkguid\": \"%s\", "
171 : "\"pkgpath\": \"%s\", "
172 : "\"conflicts\": [",
173 : ev->e_integrity_conflict.pkg_uid,
174 : ev->e_integrity_conflict.pkg_path);
175 0 : cur_conflict = ev->e_integrity_conflict.conflicts;
176 0 : while (cur_conflict != NULL) {
177 0 : if (cur_conflict->next != NULL) {
178 0 : sbuf_printf(msg, "{\"uid\":\"%s\"},",
179 : cur_conflict->uid);
180 : }
181 : else {
182 0 : sbuf_printf(msg, "{\"uid\":\"%s\"}",
183 : cur_conflict->uid);
184 0 : break;
185 : }
186 0 : cur_conflict = cur_conflict->next;
187 : }
188 0 : sbuf_cat(msg, "]}}");
189 0 : break;
190 : case PKG_EVENT_INTEGRITYCHECK_FINISHED:
191 0 : sbuf_printf(msg, "{ \"type\": \"INFO_INTEGRITYCHECK_FINISHED\", "
192 : "\"data\": {\"conflicting\": %d}}",
193 : ev->e_integrity_finished.conflicting);
194 0 : break;
195 : case PKG_EVENT_DEINSTALL_BEGIN:
196 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_BEGIN\", "
197 : "\"data\": { "
198 : "\"pkgname\": \"%n\", "
199 : "\"pkgversion\": \"%v\""
200 : "}}",
201 : ev->e_deinstall_begin.pkg,
202 : ev->e_deinstall_begin.pkg);
203 0 : break;
204 : case PKG_EVENT_DEINSTALL_FINISHED:
205 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_DEINSTALL_FINISHED\", "
206 : "\"data\": { "
207 : "\"pkgname\": \"%n\", "
208 : "\"pkgversion\": \"%v\""
209 : "}}",
210 : ev->e_deinstall_finished.pkg,
211 : ev->e_deinstall_finished.pkg);
212 0 : break;
213 : case PKG_EVENT_UPGRADE_BEGIN:
214 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_BEGIN\", "
215 : "\"data\": { "
216 : "\"pkgname\": \"%n\", "
217 : "\"pkgversion\": \"%v\" ,"
218 : "\"pkgnewversion\": \"%v\""
219 : "}}",
220 : ev->e_upgrade_begin.o,
221 : ev->e_upgrade_begin.o,
222 : ev->e_upgrade_begin.n);
223 0 : break;
224 : case PKG_EVENT_UPGRADE_FINISHED:
225 0 : pkg_sbuf_printf(msg, "{ \"type\": \"INFO_UPGRADE_FINISHED\", "
226 : "\"data\": { "
227 : "\"pkgname\": \"%n\", "
228 : "\"pkgversion\": \"%v\" ,"
229 : "\"pkgnewversion\": \"%v\""
230 : "}}",
231 : ev->e_upgrade_finished.o,
232 : ev->e_upgrade_finished.o,
233 : ev->e_upgrade_finished.n);
234 0 : break;
235 : case PKG_EVENT_LOCKED:
236 0 : pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_LOCKED\", "
237 : "\"data\": { "
238 : "\"pkgname\": \"%n\", "
239 : "\"pkgversion\": \"%n\""
240 : "}}",
241 : ev->e_locked.pkg,
242 : ev->e_locked.pkg);
243 0 : break;
244 : case PKG_EVENT_REQUIRED:
245 0 : pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_REQUIRED\", "
246 : "\"data\": { "
247 : "\"pkgname\": \"%n\", "
248 : "\"pkgversion\": \"%v\", "
249 : "\"force\": %S, "
250 : "\"required_by\": [",
251 : ev->e_required.pkg,
252 : ev->e_required.pkg,
253 0 : ev->e_required.force == 1 ? "true": "false");
254 0 : while (pkg_rdeps(ev->e_required.pkg, &dep) == EPKG_OK)
255 0 : sbuf_printf(msg, "{ \"pkgname\": \"%s\", "
256 : "\"pkgversion\": \"%s\" }, ",
257 0 : dep->name, dep->version);
258 0 : sbuf_setpos(msg, sbuf_len(msg) - 2);
259 0 : sbuf_cat(msg, "]}}");
260 0 : break;
261 : case PKG_EVENT_ALREADY_INSTALLED:
262 0 : pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_ALREADY_INSTALLED\", "
263 : "\"data\": { "
264 : "\"pkgname\": \"%n\", "
265 : "\"pkgversion\": \"%v\""
266 : "}}",
267 : ev->e_already_installed.pkg,
268 : ev->e_already_installed.pkg);
269 0 : break;
270 : case PKG_EVENT_MISSING_DEP:
271 0 : sbuf_printf(msg, "{ \"type\": \"ERROR_MISSING_DEP\", "
272 : "\"data\": { "
273 : "\"depname\": \"%s\", "
274 : "\"depversion\": \"%s\""
275 : "}}" ,
276 0 : ev->e_missing_dep.dep->name,
277 0 : ev->e_missing_dep.dep->version);
278 0 : break;
279 : case PKG_EVENT_NOREMOTEDB:
280 0 : sbuf_printf(msg, "{ \"type\": \"ERROR_NOREMOTEDB\", "
281 : "\"data\": { "
282 : "\"url\": \"%s\" "
283 : "}}" ,
284 : ev->e_remotedb.repo);
285 0 : break;
286 : case PKG_EVENT_NOLOCALDB:
287 0 : sbuf_printf(msg, "{ \"type\": \"ERROR_NOLOCALDB\", "
288 : "\"data\": {} ");
289 0 : break;
290 : case PKG_EVENT_NEWPKGVERSION:
291 0 : sbuf_printf(msg, "{ \"type\": \"INFO_NEWPKGVERSION\", "
292 : "\"data\": {} ");
293 0 : break;
294 : case PKG_EVENT_FILE_MISMATCH:
295 0 : pkg_sbuf_printf(msg, "{ \"type\": \"ERROR_FILE_MISMATCH\", "
296 : "\"data\": { "
297 : "\"pkgname\": \"%n\", "
298 : "\"pkgversion\": \"%v\", "
299 : "\"path\": \"%S\""
300 : "}}",
301 : ev->e_file_mismatch.pkg,
302 : ev->e_file_mismatch.pkg,
303 0 : sbuf_json_escape(buf, ev->e_file_mismatch.file->path));
304 0 : break;
305 : case PKG_EVENT_PLUGIN_ERRNO:
306 0 : sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", "
307 : "\"data\": {"
308 : "\"plugin\": \"%s\", "
309 : "\"msg\": \"%s(%s): %s\","
310 : "\"errno\": %d"
311 : "}}",
312 : pkg_plugin_get(ev->e_plugin_errno.plugin, PKG_PLUGIN_NAME),
313 : sbuf_json_escape(buf, ev->e_plugin_errno.func),
314 : sbuf_json_escape(buf, ev->e_plugin_errno.arg),
315 0 : sbuf_json_escape(buf, strerror(ev->e_plugin_errno.no)),
316 : ev->e_plugin_errno.no);
317 0 : break;
318 : case PKG_EVENT_PLUGIN_ERROR:
319 0 : sbuf_printf(msg, "{ \"type\": \"ERROR_PLUGIN\", "
320 : "\"data\": {"
321 : "\"plugin\": \"%s\", "
322 : "\"msg\": \"%s\""
323 : "}}",
324 : pkg_plugin_get(ev->e_plugin_error.plugin, PKG_PLUGIN_NAME),
325 0 : sbuf_json_escape(buf, ev->e_plugin_error.msg));
326 0 : break;
327 : case PKG_EVENT_PLUGIN_INFO:
328 0 : sbuf_printf(msg, "{ \"type\": \"INFO_PLUGIN\", "
329 : "\"data\": {"
330 : "\"plugin\": \"%s\", "
331 : "\"msg\": \"%s\""
332 : "}}",
333 : pkg_plugin_get(ev->e_plugin_info.plugin, PKG_PLUGIN_NAME),
334 0 : sbuf_json_escape(buf, ev->e_plugin_info.msg));
335 0 : break;
336 : case PKG_EVENT_INCREMENTAL_UPDATE:
337 0 : sbuf_printf(msg, "{ \"type\": \"INFO_INCREMENTAL_UPDATE\", "
338 : "\"data\": {"
339 : "\"name\": \"%s\", "
340 : "\"processed\": %d"
341 : "}}", ev->e_incremental_update.reponame,
342 : ev->e_incremental_update.processed);
343 0 : break;
344 : case PKG_EVENT_QUERY_YESNO:
345 0 : sbuf_printf(msg, "{ \"type\": \"QUERY_YESNO\", "
346 : "\"data\": {"
347 : "\"msg\": \"%s\","
348 : "\"default\": \"%d\""
349 : "}}", ev->e_query_yesno.msg,
350 : ev->e_query_yesno.deft);
351 0 : break;
352 : case PKG_EVENT_QUERY_SELECT:
353 0 : sbuf_printf(msg, "{ \"type\": \"QUERY_SELECT\", "
354 : "\"data\": {"
355 : "\"msg\": \"%s\","
356 : "\"ncnt\": \"%d\","
357 : "\"default\": \"%d\","
358 : "\"items\": ["
359 : , ev->e_query_select.msg,
360 : ev->e_query_select.ncnt,
361 : ev->e_query_select.deft);
362 0 : for (i = 0; i < ev->e_query_select.ncnt - 1; i++)
363 : {
364 0 : sbuf_printf(msg, "{ \"text\": \"%s\" },",
365 0 : ev->e_query_select.items[i]);
366 : }
367 0 : sbuf_printf(msg, "{ \"text\": \"%s\" } ] }}",
368 0 : ev->e_query_select.items[i]);
369 0 : break;
370 : case PKG_EVENT_PROGRESS_START:
371 0 : sbuf_printf(msg, "{ \"type\": \"INFO_PROGRESS_START\", "
372 : "\"data\": {}}");
373 0 : break;
374 : case PKG_EVENT_PROGRESS_TICK:
375 0 : sbuf_printf(msg, "{ \"type\": \"INFO_PROGRESS_TICK\", "
376 : "\"data\": { \"current\": %ld, \"total\" : %ld}}",
377 : ev->e_progress_tick.current, ev->e_progress_tick.total);
378 0 : break;
379 : case PKG_EVENT_BACKUP:
380 : case PKG_EVENT_RESTORE:
381 0 : break;
382 : default:
383 0 : break;
384 : }
385 0 : sbuf_finish(msg);
386 0 : dprintf(eventpipe, "%s\n", sbuf_data(msg));
387 0 : sbuf_delete(msg);
388 0 : sbuf_delete(buf);
389 : }
390 :
391 : void
392 384 : pkg_event_register(pkg_event_cb cb, void *data)
393 : {
394 384 : _cb = cb;
395 384 : _data = data;
396 384 : }
397 :
398 : static int
399 938 : pkg_emit_event(struct pkg_event *ev)
400 : {
401 938 : int ret = 0;
402 938 : pkg_plugins_hook_run(PKG_PLUGIN_HOOK_EVENT, ev, NULL);
403 938 : if (_cb != NULL)
404 934 : ret = _cb(_data, ev);
405 938 : pipeevent(ev);
406 938 : return (ret);
407 : }
408 :
409 : void
410 41 : pkg_emit_error(const char *fmt, ...)
411 : {
412 : struct pkg_event ev;
413 : va_list ap;
414 :
415 41 : ev.type = PKG_EVENT_ERROR;
416 :
417 41 : va_start(ap, fmt);
418 41 : vasprintf(&ev.e_pkg_error.msg, fmt, ap);
419 41 : va_end(ap);
420 :
421 41 : pkg_emit_event(&ev);
422 41 : free(ev.e_pkg_error.msg);
423 41 : }
424 :
425 : void
426 0 : pkg_emit_notice(const char *fmt, ...)
427 : {
428 : struct pkg_event ev;
429 : va_list ap;
430 :
431 0 : ev.type = PKG_EVENT_NOTICE;
432 :
433 0 : va_start(ap, fmt);
434 0 : vasprintf(&ev.e_pkg_notice.msg, fmt, ap);
435 0 : va_end(ap);
436 :
437 0 : pkg_emit_event(&ev);
438 0 : free(ev.e_pkg_error.msg);
439 0 : }
440 :
441 : void
442 0 : pkg_emit_developer_mode(const char *fmt, ...)
443 : {
444 : struct pkg_event ev;
445 : va_list ap;
446 :
447 0 : ev.type = PKG_EVENT_DEVELOPER_MODE;
448 :
449 0 : va_start(ap, fmt);
450 0 : vasprintf(&ev.e_pkg_error.msg, fmt, ap);
451 0 : va_end(ap);
452 :
453 0 : pkg_emit_event(&ev);
454 0 : free(ev.e_pkg_error.msg);
455 0 : }
456 :
457 : void
458 1 : pkg_emit_errno(const char *func, const char *arg)
459 : {
460 : struct pkg_event ev;
461 :
462 1 : ev.type = PKG_EVENT_ERRNO;
463 1 : ev.e_errno.func = func;
464 1 : ev.e_errno.arg = arg;
465 1 : ev.e_errno.no = errno;
466 :
467 1 : pkg_emit_event(&ev);
468 1 : }
469 :
470 : void
471 0 : pkg_emit_already_installed(struct pkg *p)
472 : {
473 : struct pkg_event ev;
474 :
475 0 : ev.type = PKG_EVENT_ALREADY_INSTALLED;
476 0 : ev.e_already_installed.pkg = p;
477 :
478 0 : pkg_emit_event(&ev);
479 0 : }
480 :
481 : void
482 14 : pkg_emit_fetch_begin(const char *url)
483 : {
484 : struct pkg_event ev;
485 :
486 14 : ev.type = PKG_EVENT_FETCH_BEGIN;
487 14 : ev.e_fetching.url = url;
488 :
489 14 : pkg_emit_event(&ev);
490 14 : }
491 :
492 : void
493 14 : pkg_emit_fetch_finished(const char *url)
494 : {
495 : struct pkg_event ev;
496 :
497 14 : ev.type = PKG_EVENT_FETCH_FINISHED;
498 14 : ev.e_fetching.url = url;
499 :
500 14 : pkg_emit_event(&ev);
501 14 : }
502 :
503 : void
504 0 : pkg_emit_update_remove(int total, int done)
505 : {
506 : struct pkg_event ev;
507 :
508 0 : ev.type = PKG_EVENT_UPDATE_REMOVE;
509 0 : ev.e_upd_remove.total = total;
510 0 : ev.e_upd_remove.done = done;
511 :
512 0 : pkg_emit_event(&ev);
513 0 : }
514 :
515 :
516 : void
517 0 : pkg_emit_update_add(int total, int done)
518 : {
519 : struct pkg_event ev;
520 :
521 0 : ev.type = PKG_EVENT_UPDATE_ADD;
522 0 : ev.e_upd_add.total = total;
523 0 : ev.e_upd_add.done = done;
524 :
525 0 : pkg_emit_event(&ev);
526 0 : }
527 :
528 : void
529 42 : pkg_emit_install_begin(struct pkg *p)
530 : {
531 : struct pkg_event ev;
532 :
533 42 : ev.type = PKG_EVENT_INSTALL_BEGIN;
534 42 : ev.e_install_begin.pkg = p;
535 :
536 42 : pkg_emit_event(&ev);
537 42 : }
538 :
539 : void
540 39 : pkg_emit_install_finished(struct pkg *p)
541 : {
542 : struct pkg_event ev;
543 39 : bool syslog_enabled = false;
544 :
545 39 : ev.type = PKG_EVENT_INSTALL_FINISHED;
546 39 : ev.e_install_finished.pkg = p;
547 :
548 39 : syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG"));
549 39 : if (syslog_enabled) {
550 39 : syslog(LOG_NOTICE, "%s-%s installed",
551 : p->name, p->version);
552 : }
553 :
554 39 : pkg_emit_event(&ev);
555 39 : }
556 :
557 : void
558 11 : pkg_emit_add_deps_begin(struct pkg *p)
559 : {
560 : struct pkg_event ev;
561 :
562 11 : ev.type = PKG_EVENT_ADD_DEPS_BEGIN;
563 11 : ev.e_add_deps_begin.pkg = p;
564 :
565 11 : pkg_emit_event(&ev);
566 11 : }
567 :
568 : void
569 11 : pkg_emit_add_deps_finished(struct pkg *p)
570 : {
571 : struct pkg_event ev;
572 :
573 11 : ev.type = PKG_EVENT_ADD_DEPS_FINISHED;
574 11 : ev.e_add_deps_finished.pkg = p;
575 :
576 11 : pkg_emit_event(&ev);
577 11 : }
578 :
579 : void
580 18 : pkg_emit_extract_begin(struct pkg *p)
581 : {
582 : struct pkg_event ev;
583 :
584 18 : ev.type = PKG_EVENT_EXTRACT_BEGIN;
585 18 : ev.e_extract_begin.pkg = p;
586 :
587 18 : pkg_emit_event(&ev);
588 18 : }
589 :
590 : void
591 18 : pkg_emit_extract_finished(struct pkg *p)
592 : {
593 : struct pkg_event ev;
594 :
595 18 : ev.type = PKG_EVENT_EXTRACT_FINISHED;
596 18 : ev.e_extract_finished.pkg = p;
597 :
598 18 : pkg_emit_event(&ev);
599 18 : }
600 :
601 : void
602 5 : pkg_emit_delete_files_begin(struct pkg *p)
603 : {
604 : struct pkg_event ev;
605 :
606 5 : ev.type = PKG_EVENT_DELETE_FILES_BEGIN;
607 5 : ev.e_delete_files_begin.pkg = p;
608 :
609 5 : pkg_emit_event(&ev);
610 5 : }
611 :
612 : void
613 5 : pkg_emit_delete_files_finished(struct pkg *p)
614 : {
615 : struct pkg_event ev;
616 :
617 5 : ev.type = PKG_EVENT_DELETE_FILES_FINISHED;
618 5 : ev.e_delete_files_finished.pkg = p;
619 :
620 5 : pkg_emit_event(&ev);
621 5 : }
622 :
623 : void
624 15 : pkg_emit_integritycheck_begin(void)
625 : {
626 : struct pkg_event ev;
627 15 : ev.type = PKG_EVENT_INTEGRITYCHECK_BEGIN;
628 :
629 15 : pkg_emit_event(&ev);
630 15 : }
631 :
632 : void
633 15 : pkg_emit_integritycheck_finished(int conflicting)
634 : {
635 : struct pkg_event ev;
636 15 : ev.type = PKG_EVENT_INTEGRITYCHECK_FINISHED;
637 15 : ev.e_integrity_finished.conflicting = conflicting;
638 :
639 15 : pkg_emit_event(&ev);
640 15 : }
641 :
642 : void
643 0 : pkg_emit_integritycheck_conflict(const char *uid,
644 : const char *path, struct pkg_event_conflict *conflicts)
645 : {
646 : struct pkg_event ev;
647 0 : ev.type = PKG_EVENT_INTEGRITYCHECK_CONFLICT;
648 0 : ev.e_integrity_conflict.pkg_uid = uid;
649 0 : ev.e_integrity_conflict.pkg_path = path;
650 0 : ev.e_integrity_conflict.conflicts = conflicts;
651 :
652 0 : pkg_emit_event(&ev);
653 0 : }
654 :
655 : void
656 6 : pkg_emit_deinstall_begin(struct pkg *p)
657 : {
658 : struct pkg_event ev;
659 :
660 6 : ev.type = PKG_EVENT_DEINSTALL_BEGIN;
661 6 : ev.e_deinstall_begin.pkg = p;
662 :
663 6 : pkg_emit_event(&ev);
664 6 : }
665 :
666 : void
667 6 : pkg_emit_deinstall_finished(struct pkg *p)
668 : {
669 : struct pkg_event ev;
670 6 : bool syslog_enabled = false;
671 :
672 6 : ev.type = PKG_EVENT_DEINSTALL_FINISHED;
673 6 : ev.e_deinstall_finished.pkg = p;
674 :
675 6 : syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG"));
676 6 : if (syslog_enabled) {
677 6 : syslog(LOG_NOTICE, "%s-%s deinstalled",
678 : p->name, p->version);
679 : }
680 :
681 6 : pkg_emit_event(&ev);
682 6 : }
683 :
684 : void
685 0 : pkg_emit_upgrade_begin(struct pkg *new, struct pkg *old)
686 : {
687 : struct pkg_event ev;
688 :
689 0 : ev.type = PKG_EVENT_UPGRADE_BEGIN;
690 0 : ev.e_upgrade_begin.n = new;
691 0 : ev.e_upgrade_begin.o = old;
692 :
693 0 : pkg_emit_event(&ev);
694 0 : }
695 :
696 : void
697 0 : pkg_emit_upgrade_finished(struct pkg *new, struct pkg *old)
698 : {
699 : struct pkg_event ev;
700 0 : bool syslog_enabled = false;
701 :
702 0 : ev.type = PKG_EVENT_UPGRADE_FINISHED;
703 0 : ev.e_upgrade_finished.n = new;
704 0 : ev.e_upgrade_finished.o = old;
705 :
706 0 : syslog_enabled = pkg_object_bool(pkg_config_get("SYSLOG"));
707 0 : if (syslog_enabled) {
708 0 : const char *actions[] = {
709 : [PKG_DOWNGRADE] = "downgraded",
710 : [PKG_REINSTALL] = "reinstalled",
711 : [PKG_UPGRADE] = "upgraded",
712 : };
713 : pkg_change_t action;
714 :
715 0 : action = pkg_version_change_between(new, old);
716 0 : syslog(LOG_NOTICE, "%s %s: %s %s %s ",
717 : new->name, actions[action],
718 0 : old->version != NULL ? old->version : new->version,
719 0 : old->version != NULL ? "->" : "",
720 0 : old->version != NULL ? new->version : "");
721 : }
722 :
723 0 : pkg_emit_event(&ev);
724 0 : }
725 :
726 : void
727 4 : pkg_emit_missing_dep(struct pkg *p, struct pkg_dep *d)
728 : {
729 : struct pkg_event ev;
730 :
731 4 : ev.type = PKG_EVENT_MISSING_DEP;
732 4 : ev.e_missing_dep.pkg = p;
733 4 : ev.e_missing_dep.dep = d;
734 :
735 4 : pkg_emit_event(&ev);
736 4 : }
737 :
738 : void
739 0 : pkg_emit_locked(struct pkg *p)
740 : {
741 : struct pkg_event ev;
742 :
743 0 : ev.type = PKG_EVENT_LOCKED;
744 0 : ev.e_locked.pkg = p;
745 :
746 0 : pkg_emit_event(&ev);
747 0 : }
748 :
749 : void
750 0 : pkg_emit_required(struct pkg *p, int force)
751 : {
752 : struct pkg_event ev;
753 :
754 0 : ev.type = PKG_EVENT_REQUIRED;
755 0 : ev.e_required.pkg = p;
756 0 : ev.e_required.force = force;
757 :
758 0 : pkg_emit_event(&ev);
759 0 : }
760 :
761 : void
762 0 : pkg_emit_nolocaldb(void)
763 : {
764 : struct pkg_event ev;
765 0 : ev.type = PKG_EVENT_NOLOCALDB;
766 :
767 0 : pkg_emit_event(&ev);
768 0 : }
769 :
770 : void
771 0 : pkg_emit_noremotedb(const char *repo)
772 : {
773 : struct pkg_event ev;
774 0 : ev.type = PKG_EVENT_NOREMOTEDB;
775 :
776 0 : ev.e_remotedb.repo = repo;
777 :
778 0 : pkg_emit_event(&ev);
779 0 : }
780 :
781 : void
782 0 : pkg_emit_newpkgversion(void)
783 : {
784 : struct pkg_event ev;
785 0 : ev.type = PKG_EVENT_NEWPKGVERSION;
786 :
787 0 : pkg_emit_event(&ev);
788 0 : }
789 :
790 : void
791 0 : pkg_emit_file_mismatch(struct pkg *pkg, struct pkg_file *f, const char *newsum) {
792 : struct pkg_event ev;
793 0 : ev.type = PKG_EVENT_FILE_MISMATCH;
794 :
795 0 : ev.e_file_mismatch.pkg = pkg;
796 0 : ev.e_file_mismatch.file = f;
797 0 : ev.e_file_mismatch.newsum = newsum;
798 :
799 0 : pkg_emit_event(&ev);
800 0 : }
801 :
802 : void
803 0 : pkg_plugin_errno(struct pkg_plugin *p, const char *func, const char *arg)
804 : {
805 : struct pkg_event ev;
806 :
807 0 : ev.type = PKG_EVENT_PLUGIN_ERRNO;
808 0 : ev.e_plugin_errno.plugin = p;
809 0 : ev.e_plugin_errno.func = func;
810 0 : ev.e_plugin_errno.arg = arg;
811 0 : ev.e_plugin_errno.no = errno;
812 :
813 0 : pkg_emit_event(&ev);
814 0 : }
815 :
816 : void
817 0 : pkg_plugin_error(struct pkg_plugin *p, const char *fmt, ...)
818 : {
819 : struct pkg_event ev;
820 : va_list ap;
821 :
822 0 : ev.type = PKG_EVENT_PLUGIN_ERROR;
823 0 : ev.e_plugin_error.plugin = p;
824 :
825 0 : va_start(ap, fmt);
826 0 : vasprintf(&ev.e_plugin_error.msg, fmt, ap);
827 0 : va_end(ap);
828 :
829 0 : pkg_emit_event(&ev);
830 0 : free(ev.e_plugin_error.msg);
831 0 : }
832 :
833 : void
834 0 : pkg_plugin_info(struct pkg_plugin *p, const char *fmt, ...)
835 : {
836 : struct pkg_event ev;
837 : va_list ap;
838 :
839 0 : ev.type = PKG_EVENT_PLUGIN_INFO;
840 0 : ev.e_plugin_info.plugin = p;
841 :
842 0 : va_start(ap, fmt);
843 0 : vasprintf(&ev.e_plugin_info.msg, fmt, ap);
844 0 : va_end(ap);
845 :
846 0 : pkg_emit_event(&ev);
847 0 : free(ev.e_plugin_info.msg);
848 0 : }
849 :
850 : void
851 0 : pkg_emit_package_not_found(const char *p)
852 : {
853 : struct pkg_event ev;
854 :
855 0 : ev.type = PKG_EVENT_NOT_FOUND;
856 0 : ev.e_not_found.pkg_name = p;
857 :
858 0 : pkg_emit_event(&ev);
859 0 : }
860 :
861 : void
862 7 : pkg_emit_incremental_update(const char *reponame, int processed)
863 : {
864 : struct pkg_event ev;
865 :
866 7 : ev.type = PKG_EVENT_INCREMENTAL_UPDATE;
867 7 : ev.e_incremental_update.reponame = reponame;
868 7 : ev.e_incremental_update.processed = processed;
869 :
870 7 : pkg_emit_event(&ev);
871 7 : }
872 :
873 : bool
874 0 : pkg_emit_query_yesno(bool deft, const char *msg)
875 : {
876 : struct pkg_event ev;
877 : int ret;
878 :
879 0 : ev.type = PKG_EVENT_QUERY_YESNO;
880 0 : ev.e_query_yesno.msg = msg;
881 0 : ev.e_query_yesno.deft = deft;
882 :
883 0 : ret = pkg_emit_event(&ev);
884 0 : return (ret ? true : false);
885 : }
886 :
887 : int
888 0 : pkg_emit_query_select(const char *msg, const char **items, int ncnt, int deft)
889 : {
890 : struct pkg_event ev;
891 : int ret;
892 :
893 0 : ev.type = PKG_EVENT_QUERY_SELECT;
894 0 : ev.e_query_select.msg = msg;
895 0 : ev.e_query_select.items = items;
896 0 : ev.e_query_select.ncnt = ncnt;
897 0 : ev.e_query_select.deft = deft;
898 :
899 0 : ret = pkg_emit_event(&ev);
900 0 : return ret;
901 : }
902 :
903 : int
904 14 : pkg_emit_sandbox_get_string(pkg_sandbox_cb call, void *ud, char **str, int64_t *len)
905 : {
906 : struct pkg_event ev;
907 : int ret;
908 :
909 14 : ev.type = PKG_EVENT_SANDBOX_GET_STRING;
910 14 : ev.e_sandbox_call_str.call = call;
911 14 : ev.e_sandbox_call_str.userdata = ud;
912 14 : ev.e_sandbox_call_str.result = str;
913 14 : ev.e_sandbox_call_str.len = len;
914 :
915 14 : ret = pkg_emit_event(&ev);
916 14 : return ret;
917 : }
918 :
919 : int
920 0 : pkg_emit_sandbox_call(pkg_sandbox_cb call, int fd, void *ud)
921 : {
922 : struct pkg_event ev;
923 : int ret;
924 :
925 0 : ev.type = PKG_EVENT_SANDBOX_CALL;
926 0 : ev.e_sandbox_call.call = call;
927 0 : ev.e_sandbox_call.fd = fd;
928 0 : ev.e_sandbox_call.userdata = ud;
929 :
930 0 : ret = pkg_emit_event(&ev);
931 0 : return ret;
932 : }
933 :
934 : void
935 15385 : pkg_debug(int level, const char *fmt, ...)
936 : {
937 : struct pkg_event ev;
938 : va_list ap;
939 :
940 15385 : if (debug_level < level)
941 30770 : return;
942 :
943 0 : ev.type = PKG_EVENT_DEBUG;
944 0 : ev.e_debug.level = level;
945 0 : va_start(ap, fmt);
946 0 : vasprintf(&ev.e_debug.msg, fmt, ap);
947 0 : va_end(ap);
948 :
949 0 : pkg_emit_event(&ev);
950 0 : free(ev.e_debug.msg);
951 : }
952 :
953 : void
954 0 : pkg_emit_backup(void)
955 : {
956 : struct pkg_event ev;
957 :
958 0 : ev.type = PKG_EVENT_BACKUP;
959 :
960 0 : pkg_emit_event(&ev);
961 0 : }
962 :
963 : void
964 0 : pkg_emit_restore(void)
965 : {
966 : struct pkg_event ev;
967 :
968 0 : ev.type = PKG_EVENT_RESTORE;
969 :
970 0 : pkg_emit_event(&ev);
971 0 : }
972 :
973 : void
974 274 : pkg_emit_progress_start(const char *fmt, ...)
975 : {
976 : struct pkg_event ev;
977 : va_list ap;
978 :
979 274 : ev.type = PKG_EVENT_PROGRESS_START;
980 274 : if (fmt != NULL) {
981 237 : va_start(ap, fmt);
982 237 : vasprintf(&ev.e_progress_start.msg, fmt, ap);
983 237 : va_end(ap);
984 : } else {
985 37 : ev.e_progress_start.msg = NULL;
986 : }
987 :
988 274 : pkg_emit_event(&ev);
989 274 : free(ev.e_progress_start.msg);
990 274 : }
991 :
992 : void
993 378 : pkg_emit_progress_tick(int64_t current, int64_t total)
994 : {
995 : struct pkg_event ev;
996 :
997 378 : ev.type = PKG_EVENT_PROGRESS_TICK;
998 378 : ev.e_progress_tick.current = current;
999 378 : ev.e_progress_tick.total = total;
1000 :
1001 378 : pkg_emit_event(&ev);
1002 :
1003 378 : }
|
