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