7 #if defined(WITH_SEMANAGE)
8 #include <semanage/semanage.h>
11 #define _RPMSM_INTERNAL
26 #define F_ISSET(_sm, _FLAG) (((_sm)->flags & ((RPMSM_FLAGS_##_FLAG) & ~0x40000000)) != RPMSM_FLAGS_NONE)
38 #if defined(WITH_SEMANAGE)
39 static int rpmsmChk(
rpmsm sm,
int rc,
const char * msg)
41 if (rc < 0 && msg != NULL) {
52 static int rpmsmSelect(
rpmsm sm,
char *
arg)
58 semanage_select_store(sm->I, arg, SEMANAGE_CON_DIRECT);
61 sm->fn =
_free(sm->fn);
65 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
70 static int rpmsmAccess(
rpmsm sm,
char * arg)
74 if ((rc = rpmsmSelect(sm, arg)) < 0)
77 rc = rpmsmChk(sm, semanage_access_check(sm->I),
"access_check");
81 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
86 static int rpmsmCreate(
rpmsm sm,
char * arg)
90 if ((sm->access = rc = rpmsmAccess(sm, arg)) < SEMANAGE_CAN_READ) {
95 semanage_set_create_store(sm->I, (
F_ISSET(sm, CREATE) ? 1 : 0));
99 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
104 static int rpmsmConnect(
rpmsm sm,
char * arg)
108 if ((rc = rpmsmCreate(sm, arg)) < 0)
110 if (!semanage_is_connected(sm->I))
111 rc = rpmsmChk(sm, semanage_connect(sm->I),
"connect");
115 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
124 #if defined(WITH_SEMANAGE)
126 rc = rpmsmChk(sm, semanage_begin_transaction(sm->I),
"begin_transaction");
130 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
139 #if defined(WITH_SEMANAGE)
141 if (semanage_is_connected(sm->I))
142 rc = rpmsmChk(sm, semanage_disconnect(sm->I),
"disconnect");
144 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
155 #if defined(WITH_SEMANAGE)
157 if ((rc = rpmsmConnect(sm, sm->fn)) < 0)
161 fprintf(stderr,
"--> %s(%p,%s) I %p\n", __FUNCTION__, sm, arg, sm->I);
162 rc = rpmsmChk(sm, semanage_reload_policy(sm->I),
"reload_policy");
164 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
172 #if defined(WITH_SEMANAGE)
174 if ((rc = rpmsmConnect(sm, sm->fn)) < 0)
177 rc = rpmsmChk(sm, semanage_module_install_base_file(sm->I, arg),
"module_install_base_file");
181 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
189 #if defined(WITH_SEMANAGE)
191 if ((rc = rpmsmConnect(sm, sm->fn)) < 0)
195 fprintf(stderr,
"--> %s(%p,%s) I %p\n", __FUNCTION__, sm, arg, sm->I);
196 rc = rpmsmChk(sm, semanage_module_install_file(sm->I, arg),
"module_install_file");
200 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
208 #if defined(WITH_SEMANAGE)
210 if ((rc = rpmsmConnect(sm, sm->fn)) < 0)
214 fprintf(stderr,
"--> %s(%p,%s) I %p\n", __FUNCTION__, sm, arg, sm->I);
215 rc = rpmsmChk(sm, semanage_module_upgrade_file(sm->I, arg),
"module_upgrade_file");
219 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
227 #if defined(WITH_SEMANAGE)
229 if ((rc = rpmsmConnect(sm, sm->fn)) < 0)
232 rc = rpmsmChk(sm, semanage_module_remove(sm->I, arg),
"module_remove");
236 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
244 #if defined(WITH_SEMANAGE)
245 semanage_module_info_t *modules = NULL;
249 if ((rc = rpmsmConnect(sm, sm->fn)) < 0)
252 rc = rpmsmChk(sm, semanage_module_list(sm->I, &modules, &nmodules),
"module_list");
264 for (j = 0; j < nmodules; j++) {
265 semanage_module_info_t * m = semanage_module_list_nth(modules, j);
266 char * NV =
rpmExpand(semanage_module_get_name(m),
"-",
267 semanage_module_get_version(m), NULL);
269 || !(
mireApply(include, ninclude, NV, 0, +1) < 0))
272 semanage_module_info_datum_destroy(m);
276 modules =
_free(modules);
279 fprintf(stderr,
"<-- %s(%p,%s) I %p rc %d\n", __FUNCTION__, sm, arg, sm->I, rc);
287 #if defined(WITH_SEMANAGE)
289 semanage_set_reload(sm->I, (
F_ISSET(sm, RELOAD) ? 1 : 0));
290 semanage_set_rebuild(sm->I, (
F_ISSET(sm, REBUILD) ? 1 : 0));
291 semanage_set_disable_dontaudit(sm->I, (
F_ISSET(sm, NOAUDIT) ? 1 : 0));
292 rc = rpmsmChk(sm, semanage_commit(sm->I),
"commit");
297 fprintf(stderr,
"<-- %s(%p) I %p rc %d\n", __FUNCTION__, sm, sm->I, rc);
310 #if defined(WITH_SEMANAGE)
313 semanage_handle_destroy(sm->I);
318 sm->fn =
_free(sm->fn);
335 if (_rpmsmPool == NULL) {
355 #if defined(WITH_SEMANAGE)
359 if ((sm->I = semanage_handle_create()) == NULL)
364 rc = rpmsmConnect(sm, (
char *)fn);
366 rc = rpmsmCreate(sm, (
char *)fn);
368 rc = rpmsmAccess(sm, (
char *)fn);
370 rc = rpmsmSelect(sm, (
char *)fn);
407 fprintf(stderr,
"--> %s(%p,%p,%p) av[0] \"%s\"\n", __FUNCTION__, sm, av, resultp, (av ? av[0] : NULL));
409 if (sm == NULL) sm =
rpmsmI();
413 for (i = 0; i < ncmds; i++) {
414 char *
cmd = (
char *)av[i];
415 char * arg = strchr(cmd+1,
' ');
459 if (!rc &&
F_ISSET(sm, COMMIT))
475 fprintf(stderr,
"<-- %s(%p,%p,%p) av[0] \"%s\" rc %d\n", __FUNCTION__, sm, av, resultp, (av ? av[0] : NULL), rc);
rpmiob rpmiobRTrim(rpmiob iob)
Trim trailing white space.
static const char _rpmsmI_fn[]
rpmsm rpmsmFree(rpmsm sm)
Destroy a semanage wrapper.
miRE mireNew(rpmMireMode mode, int tag)
Create pattern container.
int mireApply(miRE mire, int nmire, const char *s, size_t slen, int rc)
Apply array of patterns to a string.
rpmsm rpmsmLink(rpmsm sm)
Reference a semanage wrapper instance.
const char const char * cmd
char * xstrdup(const char *str)
size_t rpmiobLen(rpmiob iob)
Return I/O buffer len.
static int rpmsmList(rpmsm sm, char *arg)
int mireRegcomp(miRE mire, const char *pattern)
Compile pattern match.
static int rpmsmInstallBase(rpmsm sm, char *arg)
static int rpmsmReload(rpmsm sm, char *arg)
rpmiob rpmiobFree(rpmiob iob)
Destroy a I/O buffer instance.
rpmiob rpmiobAppend(rpmiob iob, const char *s, size_t nl)
Append string to I/O buffer.
Yet Another syslog(3) API clone.
static rpmsm rpmsmI(void)
miRE mireFree(miRE mire)
Free pattern container.
static int rpmsmDisconnect(rpmsm sm, char *arg)
rpmioItem rpmioGetPool(rpmioPool pool, size_t size)
Get unused item from pool, or alloc a new item.
int argvCount(const ARGV_t argv)
Return no.
static int rpmsmCommit(rpmsm sm, char *arg)
static int xisspace(int c)
static int rpmsmInstall(rpmsm sm, char *arg)
ARGV_t argvFree(ARGV_t argv)
Destroy an argv array.
rpmRC rpmsmRun(rpmsm sm, char **av, const char **resultp)
Run semanage commands.
static int rpmsmBegin(rpmsm sm, char *arg)
#define F_ISSET(_sm, _FLAG)
char * rpmExpand(const char *arg,...)
Return (malloc'ed) concatenated macro expansion(s).
const char const char int arg
rpmiob rpmiobNew(size_t len)
Create an I/O buffer.
const char const bson int mongo_write_concern int flags
rpmsm rpmsmNew(const char *fn, unsigned int flags)
Create and load a semanage wrapper.
enum rpmRC_e rpmRC
RPM return codes.
char * rpmiobStr(rpmiob iob)
Return I/O buffer (as string).
rpmioPool rpmioNewPool(const char *name, size_t size, int limit, int flags, char *(*dbg)(void *item), void(*init)(void *item), void(*fini)(void *item))
Create a memory pool.
static int rpmsmUpgrade(rpmsm sm, char *arg)
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
static void rpmsmFini(void *_sm)
rpmiob rpmiobEmpty(rpmiob iob)
Empty an I/O buffer.
static int rpmsmRemove(rpmsm sm, char *arg)
static rpmsm rpmsmGetPool(rpmioPool pool)