void layer_raster::reset_table_defs()
{
if (m_tbls.empty())
return;
for (size_t lvl(0); lvl < m_raster.levels.size(); ++lvl)
get_provider()->reset_table_def(m_raster.levels[lvl].geometry);
}
CL_Size CL_Font::get_text_size(CL_GraphicContext &gc, const CL_StringRef &text)
{
CL_Size total_size;
if (!impl.is_null())
{
CL_FontMetrics fm = get_font_metrics(gc);
int line_spacing = fm.get_external_leading();
std::vector<CL_String> lines = CL_StringHelp::split_text(text, "\n", false);
for (std::vector<CL_String>::size_type i=0; i<lines.size(); i++)
{
CL_Size line_size = get_provider()->get_text_size(gc, lines[i]);
if ((line_size.width == 0) && (line_size.height == 0) && (lines.size() > 1)) // blank line
line_size.height = fm.get_descent() + fm.get_ascent();
if ((i+1) != lines.size()) // Do not add the line spacing on the last line
line_size.height += line_spacing;
if (total_size.width < line_size.width) // Find the widest line
total_size.width = line_size.width;
total_size.height += line_size.height;
}
}
return total_size;
}
PixelBuffer GraphicContext::get_pixeldata(const Rect &rect2, TextureFormat texture_format, bool clamp)
{
Rect rect = rect2;
if (rect == Rect())
rect = Rect(0, 0, get_size());
return get_provider()->get_pixeldata(rect, texture_format, clamp);
}
HCRYPTHASH create()
{
HCRYPTHASH ret;
if (CryptCreateHash(get_provider(), AlgId, 0, 0, &ret) == false)
{
throw_ex<system_error>(error_code(GetLastError(), system_category()));
}
return ret;
}
TEST (QofSessionTest, safe_save)
{
qof_backend_register_provider (get_provider ());
QofSession s;
s.begin ("book1", false, false, false);
s.safe_save (nullptr);
EXPECT_EQ (safe_sync_called, true);
qof_backend_unregister_all_providers ();
safe_sync_called = false;
}
TEST (QofSessionTest, ensure_all_data_loaded)
{
qof_backend_register_provider (get_provider ());
QofSession s;
s.begin ("book1", false, false, false);
data_loaded = false;
s.ensure_all_data_loaded ();
EXPECT_EQ (data_loaded, true);
qof_backend_unregister_all_providers ();
}
std::shared_ptr<brig::rowset> layer_raster::attributes(const frame& fr)
{
size_t level(get_level(fr));
auto tbl(get_table_def(level));
for (size_t i(0); i < tbl.columns.size(); ++i)
if (tbl.columns[i].name == m_raster.levels[level].geometry.qualifier)
tbl.columns[i].query_value = prepare_box(fr);
tbl.query_rows = int(brig::PageSize);
return get_provider()->select(tbl);
}
TEST (QofSessionTest, pop_error)
{
qof_backend_register_provider (get_provider ());
QofSession s;
s.begin ("book1", false, false, false);
//We run the test first, and make sure there is an error condition.
s.ensure_all_data_loaded ();
EXPECT_NE (s.pop_error (), ERR_BACKEND_NO_ERR);
EXPECT_EQ (s.get_error (), ERR_BACKEND_NO_ERR);
qof_backend_unregister_all_providers ();
}
TEST (QofSessionTest, get_error)
{
qof_backend_register_provider (get_provider ());
QofSession s;
s.begin ("book1", false, false, false);
s.ensure_all_data_loaded ();
EXPECT_NE (s.get_error (), ERR_BACKEND_NO_ERR);
//get_error should not clear the error.
EXPECT_NE (s.get_error (), ERR_BACKEND_NO_ERR);
qof_backend_unregister_all_providers ();
}
cache_provider_list *cache_get_providers(request_rec *r,
cache_server_conf *conf,
apr_uri_t uri)
{
cache_dir_conf *dconf = ap_get_module_config(r->per_dir_config, &cache_module);
cache_provider_list *providers = NULL;
int i;
/* per directory cache disable */
if (dconf->disable) {
return NULL;
}
/* global cache disable */
for (i = 0; i < conf->cachedisable->nelts; i++) {
struct cache_disable *ent =
(struct cache_disable *)conf->cachedisable->elts;
if (uri_meets_conditions(&ent[i].url, ent[i].pathlen, &uri)) {
/* Stop searching now. */
return NULL;
}
}
/* loop through all the per directory cacheenable entries */
for (i = 0; i < dconf->cacheenable->nelts; i++) {
struct cache_enable *ent =
(struct cache_enable *)dconf->cacheenable->elts;
providers = get_provider(r, &ent[i], providers);
}
/* loop through all the global cacheenable entries */
for (i = 0; i < conf->cacheenable->nelts; i++) {
struct cache_enable *ent =
(struct cache_enable *)conf->cacheenable->elts;
if (uri_meets_conditions(&ent[i].url, ent[i].pathlen, &uri)) {
providers = get_provider(r, &ent[i], providers);
}
}
return providers;
}
/*
* The top level function for the "cryptoadm uninstall" subcommand.
*/
static int
do_uninstall(int argc, char **argv)
{
cryptoadm_provider_t *prov = NULL;
int rc = SUCCESS;
if (argc != 3) {
usage();
return (ERROR_USAGE);
}
prov = get_provider(argc, argv);
if (prov == NULL ||
prov->cp_type == PROV_BADNAME || prov->cp_type == PROV_KEF_HARD) {
/*
* TRANSLATION_NOTE
* "uninstall" could be either a literal keyword and hence
* not to be translated, or a verb and translatable. A
* choice was made to view it as a literal keyword.
*/
cryptoerror(LOG_STDERR,
gettext("bad provider name for %s."), "uninstall");
free(prov);
return (FAILURE);
}
if (prov->cp_type == PROV_UEF_LIB) {
rc = uninstall_uef_lib(prov->cp_name);
} else if (prov->cp_type == PROV_KEF_SOFT) {
if (getzoneid() == GLOBAL_ZONEID) {
/* unload and remove from kcf.conf */
rc = uninstall_kef(prov->cp_name);
} else {
/*
* TRANSLATION_NOTE
* "uninstall" could be either a literal keyword and
* hence not to be translated, or a verb and
* translatable. A choice was made to view it as a
* literal keyword. "global" is keyword and not to
* be translated.
*/
cryptoerror(LOG_STDERR, gettext("%1$s for kernel "
"providers is supported in the %2$s zone only"),
"uninstall", "global");
rc = FAILURE;
}
}
free(prov);
return (rc);
}
HCRYPTHASH create()
{
HCRYPTHASH ret;
if (CryptCreateHash(get_provider(), AlgId, 0, 0, &ret) == false)
{
#ifndef BOOST_NO_EXCEPTIONS
throw system_error(error_code(GetLastError(), system_category()));
#else
std::terminate();
#endif
}
return ret;
}
void CL_Font::draw_text(CL_GraphicContext &gc, float dest_x, float dest_y, const CL_StringRef &text, const CL_Colorf &color)
{
if (!impl.is_null())
{
CL_FontMetrics fm = get_font_metrics(gc);
int line_spacing = fm.get_height() + fm.get_external_leading();
std::vector<CL_String> lines = CL_StringHelp::split_text(text, "\n", false);
for (std::vector<CL_String>::size_type i=0; i<lines.size(); i++)
{
get_provider()->draw_text(gc, dest_x, dest_y, lines[i], color);
dest_y += line_spacing;
}
}
}
/**
* Goto a place when we already have a string to search on
*
* Returns: %TRUE if a successful lookup
*/
static gboolean vik_goto_place ( VikWindow *vw, VikViewport *vvp, gchar* name, VikCoord *vcoord )
{
// Ensure last_goto_tool is given a value
get_provider ();
if ( goto_tools_list ) {
VikGotoTool *gototool = g_list_nth_data ( goto_tools_list, last_goto_tool );
if ( gototool ) {
if ( vik_goto_tool_get_coord ( gototool, vw, vvp, name, vcoord ) == 0 )
return TRUE;
}
}
return FALSE;
}
TEST (QofSessionTest, swap_books)
{
qof_backend_register_provider (get_provider ());
QofSession s1;
s1.begin ("book1", false, false, false);
QofSession s2;
s2.begin ("book2", false, false, false);
QofBook * b1 {s1.get_book ()};
QofBook * b2 {s2.get_book ()};
ASSERT_NE (b1, b2);
s1.swap_books (s2);
EXPECT_EQ (s1.get_book (), b2);
EXPECT_EQ (s2.get_book (), b1);
qof_backend_unregister_all_providers ();
}
TEST (QofSessionTest, export_session)
{
qof_backend_register_provider (get_provider ());
QofSession s1;
s1.begin ("book1", false, false, false);
QofSession s2;
s2.begin ("book2", false, false, false);
QofBook * b1 = s1.get_book ();
QofBook * b2 = s2.get_book ();
b1->backend = s1.get_backend ();
b2->backend = s2.get_backend ();
s2.export_session (s1, nullptr);
EXPECT_EQ (exported_book, b1);
qof_backend_unregister_all_providers ();
}
brig::table_def layer_raster::get_table_def(size_t lvl)
{
auto tbl
( m_tbls.empty()
? get_provider()->get_table_def(m_raster.levels[lvl].geometry)
: m_tbls[lvl]
);
if (!m_raster.levels[lvl].raster.query_expression.empty())
tbl.columns.push_back(m_raster.levels[lvl].raster);
for (const auto& cnd: m_raster.levels[lvl].query_conditions)
{
auto col(tbl[cnd.name]);
if (!cnd.query_expression.empty()) col->query_expression = cnd.query_expression;
col->query_value = cnd.query_value;
}
return tbl;
}
TEST (QofSessionTest, load)
{
// We register a provider that gives a backend that
// throws an error on load.
// This error during load should cause the qof session to
// "roll back" the book load.
qof_backend_register_provider (get_provider ());
QofSession s;
s.begin ("book1", false, false, false);
auto book = s.get_book ();
s.load (nullptr);
EXPECT_EQ (book, s.get_book ());
// Now we'll do the load without returning an error from the backend,
// and ensure that the book changed to a new book.
load_error = false;
s.load (nullptr);
EXPECT_NE (book, s.get_book ());
// I'll put load_error back just to be tidy.
load_error = true;
qof_backend_unregister_all_providers ();
}
static void handle_accept(uint32_t events) {
if (events != EPOLLIN) {
syslog(LOG_ERR, "unexpected event on listening socket: %u\n", (unsigned)events);
exit(1);
}
int fd = accept4(listen_fd, NULL, NULL, SOCK_CLOEXEC);
if (fd < 0) {
syslog(LOG_WARNING, "accept4: %s\n", strerror(errno));
return;
}
FILE *file = fdopen(fd, "r+");
if (!file) {
syslog(LOG_WARNING, "fdopen: %s\n", strerror(errno));
close(fd);
return;
}
char command[1024];
bool ok = fgets(command, sizeof(command), file);
if (!ok || !command[0] || !feof(file)) {
fclose(file);
return;
}
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK);
provider_t *p = get_provider(command);
if (!p) {
fclose(file);
return;
}
add_client(p, file);
handle_data(p);
}
static gchar *a_prompt_for_goto_string(VikWindow *vw)
{
GtkWidget *dialog = NULL;
dialog = gtk_dialog_new_with_buttons ( "", GTK_WINDOW(vw), 0, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL );
gtk_window_set_title(GTK_WINDOW(dialog), _("goto"));
GtkWidget *tool_label = gtk_label_new(_("goto provider:"));
GtkWidget *tool_list = vik_combo_box_text_new ();
GList *current = g_list_first (goto_tools_list);
while (current != NULL)
{
char *label = NULL;
VikGotoTool *tool = current->data;
label = vik_goto_tool_get_label (tool);
vik_combo_box_text_append ( tool_list, label );
current = g_list_next (current);
}
get_provider ();
gtk_combo_box_set_active ( GTK_COMBO_BOX( tool_list ), last_goto_tool );
GtkWidget *goto_label = gtk_label_new(_("Enter address or place name:"));
GtkWidget *goto_entry = gtk_entry_new();
if (last_goto_str)
gtk_entry_set_text(GTK_ENTRY(goto_entry), last_goto_str);
// 'ok' when press return in the entry
g_signal_connect_swapped (goto_entry, "activate", G_CALLBACK(a_dialog_response_accept), dialog);
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tool_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), tool_list, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), goto_label, FALSE, FALSE, 5 );
gtk_box_pack_start ( GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), goto_entry, FALSE, FALSE, 5 );
gtk_dialog_set_default_response ( GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT );
gtk_widget_show_all(dialog);
// Ensure the text field has focus so we can start typing straight away
gtk_widget_grab_focus ( goto_entry );
if ( gtk_dialog_run ( GTK_DIALOG(dialog) ) != GTK_RESPONSE_ACCEPT ) {
gtk_widget_destroy(dialog);
return NULL;
}
// TODO check if list is empty
last_goto_tool = gtk_combo_box_get_active ( GTK_COMBO_BOX(tool_list) );
gchar *provider = vik_goto_tool_get_label ( g_list_nth_data (goto_tools_list, last_goto_tool) );
a_settings_set_string ( VIK_SETTINGS_GOTO_PROVIDER, provider );
gchar *goto_str = g_strdup ( gtk_entry_get_text ( GTK_ENTRY(goto_entry) ) );
gtk_widget_destroy(dialog);
if (goto_str[0] != '\0') {
if (last_goto_str)
g_free(last_goto_str);
last_goto_str = g_strdup(goto_str);
}
return(goto_str); /* goto_str needs to be freed by caller */
}
void CL_FadeFilter::fade_to_volume(float new_volume, int duration)
{
get_provider()->fade_to_volume(new_volume, duration);
}
void CL_FadeFilter::set_volume(float new_volume)
{
get_provider()->set_volume(new_volume);
}
float CL_FadeFilter::get_volume() const
{
return get_provider()->get_volume();
}
static void monitor_process_details_reader(struct s_client *cl) {
char tbuffer1[64], tbuffer2[64], buf[256] = { 0 }, tmpbuf[256] = { 0 }, valid_to[32] = { 0 };
struct s_reader *rdr = cl->reader;
if (!rdr) {
monitor_send_details("Reader do not exist or it is not started.", cl->tid);
return;
}
if (rdr->card_valid_to) {
struct tm vto_t;
localtime_r(&rdr->card_valid_to, &vto_t);
strftime(valid_to, sizeof(valid_to) - 1, "%Y-%m-%d", &vto_t);
} else {
strncpy(valid_to, "n/a", 3);
}
snprintf(tmpbuf, sizeof(tmpbuf) - 1, "Cardsystem: %s Reader: %s ValidTo: %s HexSerial: %s ATR: %s",
rdr->csystem.desc,
rdr->label,
valid_to,
cs_hexdump(1, rdr->hexserial, 8, tbuffer2, sizeof(tbuffer2)),
rdr->card_atr_length
? cs_hexdump(1, rdr->card_atr, rdr->card_atr_length, buf, sizeof(buf))
: ""
);
monitor_send_details(tmpbuf, cl->tid);
if (!rdr->ll_entitlements) {
monitor_send_details("No entitlements for the reader.", cl->tid);
return;
}
S_ENTITLEMENT *item;
LL_ITER itr = ll_iter_create(rdr->ll_entitlements);
time_t now = (time(NULL) / 84600) * 84600;
while ((item = ll_iter_next(&itr))) {
struct tm start_t, end_t;
localtime_r(&item->start, &start_t);
localtime_r(&item->end , &end_t);
strftime(tbuffer1, sizeof(tbuffer1) - 1, "%Y-%m-%d %H:%M %z", &start_t);
strftime(tbuffer2, sizeof(tbuffer2) - 1, "%Y-%m-%d %H:%M %z", &end_t);
char *entresname = get_tiername(item->id & 0xFFFF, item->caid, buf);
if (!entresname[0])
entresname = get_provider(item->caid, item->provid, buf, sizeof(buf));
snprintf(tmpbuf, sizeof(tmpbuf) - 1, "%s Type: %s CAID: %04X Provid: %06X ID: %08X%08X Class: %08X StartDate: %s ExpireDate: %s Name: %s",
item->end > now ? "active " : "expired",
entitlement_type[item->type],
item->caid,
item->provid,
(uint32_t)(item->id >> 32),
(uint32_t)(item->id),
item->class,
tbuffer1,
tbuffer2,
entresname
);
monitor_send_details(tmpbuf, cl->tid);
}
}
/*
* The top level function for the "cryptoadm install" subcommand.
*/
static int
do_install(int argc, char **argv)
{
cryptoadm_provider_t *prov = NULL;
int rc;
if (argc < 3) {
usage();
return (ERROR_USAGE);
}
prov = get_provider(argc, argv);
if (prov == NULL ||
prov->cp_type == PROV_BADNAME || prov->cp_type == PROV_KEF_HARD) {
/*
* TRANSLATION_NOTE
* "install" could be either a literal keyword and hence
* not to be translated, or a verb and translatable. A
* choice was made to view it as a literal keyword.
*/
cryptoerror(LOG_STDERR,
gettext("bad provider name for %s."), "install");
rc = FAILURE;
goto out;
}
if (prov->cp_type == PROV_UEF_LIB) {
rc = install_uef_lib(prov->cp_name);
goto out;
}
/* It is the PROV_KEF_SOFT type now */
/* check if there are mechanism operands */
if (argc < 4) {
/*
* TRANSLATION_NOTE
* "mechanism" could be either a literal keyword and hence
* not to be translated, or a descriptive word and
* translatable. A choice was made to view it as a literal
* keyword.
*/
cryptoerror(LOG_STDERR,
gettext("need %s operands for installing a"
" kernel software provider."), "mechanism");
rc = ERROR_USAGE;
goto out;
}
if ((rc = process_mech_operands(argc, argv, B_FALSE)) != SUCCESS) {
goto out;
}
if (allflag == B_TRUE) {
/*
* TRANSLATION_NOTE
* "all", "mechanism", and "install" are all keywords and
* not to be translated.
*/
cryptoerror(LOG_STDERR,
gettext("can not use the %1$s keyword for %2$s "
"in the %3$s subcommand."), "all", "mechanism", "install");
rc = ERROR_USAGE;
goto out;
}
if (getzoneid() == GLOBAL_ZONEID) {
rc = install_kef(prov->cp_name, mecharglist);
} else {
/*
* TRANSLATION_NOTE
* "install" could be either a literal keyword and hence
* not to be translated, or a verb and translatable. A
* choice was made to view it as a literal keyword.
* "global" is keyword and not to be translated.
*/
cryptoerror(LOG_STDERR, gettext("%1$s for kernel providers "
"is supported in the %2$s zone only"), "install", "global");
rc = FAILURE;
}
out:
free(prov);
return (rc);
}
/*
* The top level function for the "cryptoadm enable" subcommand.
*/
static int
do_enable(int argc, char **argv)
{
cryptoadm_provider_t *prov = NULL;
int rc = SUCCESS;
char *alt_token = NULL, *alt_slot = NULL;
boolean_t use_default = B_FALSE;
boolean_t auto_key_migrate_flag = B_FALSE;
if ((argc == 3) && (strncmp(argv[2], FIPS_KEYWORD,
strlen(FIPS_KEYWORD))) == 0) {
/*
* cryptoadm enable fips-140
*/
rc = do_fips_actions(FIPS140_ENABLE, NOT_REFRESH);
return (rc);
}
if ((argc < 3) || (argc > 6)) {
usage();
return (ERROR_USAGE);
}
prov = get_provider(argc, argv);
if (prov == NULL) {
usage();
return (ERROR_USAGE);
}
if ((prov->cp_type != METASLOT) && (argc != 4)) {
usage();
return (ERROR_USAGE);
}
if (prov->cp_type == PROV_BADNAME) {
rc = FAILURE;
goto out;
}
if (prov->cp_type == METASLOT) {
if ((rc = process_metaslot_operands(argc, argv, &alt_token,
&alt_slot, &use_default, &auto_key_migrate_flag))
!= SUCCESS) {
usage();
goto out;
}
if ((alt_slot || alt_token) && use_default) {
usage();
rc = FAILURE;
goto out;
}
} else {
if ((rc = process_feature_operands(argc, argv)) != SUCCESS) {
goto out;
}
/*
* If allflag or rndflag has already been set there is
* no reason to process mech=
*/
if (!allflag && !rndflag &&
(rc = process_mech_operands(argc, argv, B_FALSE))
!= SUCCESS) {
goto out;
}
}
switch (prov->cp_type) {
case METASLOT:
rc = enable_metaslot(alt_token, alt_slot, use_default,
mecharglist, allflag, auto_key_migrate_flag);
break;
case PROV_UEF_LIB:
rc = enable_uef_lib(prov->cp_name, rndflag, allflag,
mecharglist);
break;
case PROV_KEF_SOFT:
case PROV_KEF_HARD:
if (rndflag && !allflag) {
if ((mecharglist = create_mech(RANDOM)) == NULL) {
rc = FAILURE;
break;
}
}
if (getzoneid() == GLOBAL_ZONEID) {
rc = enable_kef(prov->cp_name, rndflag, allflag,
mecharglist);
} else {
/*
* TRANSLATION_NOTE
* "enable" could be either a literal keyword
* and hence not to be translated, or a verb and
* translatable. A choice was made to view it as
* a literal keyword. "global" is keyword and not
* to be translated.
*/
cryptoerror(LOG_STDERR, gettext("%1$s for kernel "
"providers is supported in the %2$s zone only"),
"enable", "global");
rc = FAILURE;
}
break;
default: /* should not come here */
rc = FAILURE;
break;
}
out:
free(prov);
if (mecharglist != NULL) {
free_mechlist(mecharglist);
}
if (alt_token != NULL) {
free(alt_token);
}
if (alt_slot != NULL) {
free(alt_slot);
}
return (rc);
}
/*
* The top level function for the "cryptoadm list" subcommand and options.
*/
static int
do_list(int argc, char **argv)
{
boolean_t mflag = B_FALSE;
boolean_t pflag = B_FALSE;
boolean_t vflag = B_FALSE;
char ch;
cryptoadm_provider_t *prov = NULL;
int rc = SUCCESS;
if ((argc == 3) && (strncmp(argv[2], FIPS_KEYWORD,
strlen(FIPS_KEYWORD))) == 0) {
/*
* cryptoadm list fips-140
*/
rc = do_fips_actions(FIPS140_STATUS, NOT_REFRESH);
return (rc);
}
argc -= 1;
argv += 1;
if (argc == 1) {
rc = list_simple_for_all(B_FALSE);
goto out;
}
/*
* cryptoadm list [-v] [-m] [-p] [provider=<>] [mechanism=<>]
*/
if (argc > 5) {
usage();
return (rc);
}
while ((ch = getopt(argc, argv, "mpv")) != EOF) {
switch (ch) {
case 'm':
mflag = B_TRUE;
if (pflag) {
rc = ERROR_USAGE;
}
break;
case 'p':
pflag = B_TRUE;
if (mflag || vflag) {
rc = ERROR_USAGE;
}
break;
case 'v':
vflag = B_TRUE;
if (pflag)
rc = ERROR_USAGE;
break;
default:
rc = ERROR_USAGE;
break;
}
}
if (rc == ERROR_USAGE) {
usage();
return (rc);
}
if ((rc = process_feature_operands(argc, argv)) != SUCCESS) {
goto out;
}
prov = get_provider(argc, argv);
if (mflag || vflag) {
if (argc > 0) {
rc = process_mech_operands(argc, argv, B_TRUE);
if (rc == FAILURE)
goto out;
/* "-m" is implied when a mechanism list is given */
if (mecharglist != NULL || allflag)
mflag = B_TRUE;
}
}
if (prov == NULL) {
if (mflag) {
rc = list_mechlist_for_all(vflag);
} else if (pflag) {
rc = list_policy_for_all();
} else if (vflag) {
rc = list_simple_for_all(vflag);
}
} else if (prov->cp_type == METASLOT) {
if ((!mflag) && (!vflag) && (!pflag)) {
/* no flag is specified, just list metaslot status */
rc = list_metaslot_info(mflag, vflag, mecharglist);
} else if (mflag || vflag) {
rc = list_metaslot_info(mflag, vflag, mecharglist);
} else if (pflag) {
rc = list_metaslot_policy();
} else {
/* error message */
usage();
rc = ERROR_USAGE;
}
} else if (prov->cp_type == PROV_BADNAME) {
usage();
rc = ERROR_USAGE;
goto out;
} else { /* do the listing for a provider only */
char *provname = prov->cp_name;
if (mflag || vflag) {
if (vflag)
(void) printf(gettext("Provider: %s\n"),
provname);
switch (prov->cp_type) {
case PROV_UEF_LIB:
rc = list_mechlist_for_lib(provname,
mecharglist, NULL, B_FALSE, vflag, mflag);
break;
case PROV_KEF_SOFT:
rc = list_mechlist_for_soft(provname,
NULL, NULL);
break;
case PROV_KEF_HARD:
rc = list_mechlist_for_hard(provname);
break;
default: /* should not come here */
rc = FAILURE;
break;
}
} else if (pflag) {
switch (prov->cp_type) {
case PROV_UEF_LIB:
rc = list_policy_for_lib(provname);
break;
case PROV_KEF_SOFT:
if (getzoneid() == GLOBAL_ZONEID) {
rc = list_policy_for_soft(provname,
NULL, NULL);
} else {
/*
* TRANSLATION_NOTE
* "global" is keyword and not to
* be translated.
*/
cryptoerror(LOG_STDERR, gettext(
"policy information for kernel "
"providers is available "
"in the %s zone only"), "global");
rc = FAILURE;
}
break;
case PROV_KEF_HARD:
if (getzoneid() == GLOBAL_ZONEID) {
rc = list_policy_for_hard(
provname, NULL, NULL, NULL);
} else {
/*
* TRANSLATION_NOTE
* "global" is keyword and not to
* be translated.
*/
cryptoerror(LOG_STDERR, gettext(
"policy information for kernel "
"providers is available "
"in the %s zone only"), "global");
rc = FAILURE;
}
break;
default: /* should not come here */
rc = FAILURE;
break;
}
} else {
/* error message */
usage();
rc = ERROR_USAGE;
}
}
out:
if (prov != NULL)
free(prov);
if (mecharglist != NULL)
free_mechlist(mecharglist);
return (rc);
}
/*
* The top level function for the "cryptoadm unload" subcommand.
*/
static int
do_unload(int argc, char **argv)
{
cryptoadm_provider_t *prov = NULL;
entry_t *pent = NULL;
boolean_t in_kernel = B_FALSE;
int rc = SUCCESS;
char *provname = NULL;
if (argc != 3) {
usage();
return (ERROR_USAGE);
}
/* check if it is a kernel software provider */
prov = get_provider(argc, argv);
if (prov == NULL) {
cryptoerror(LOG_STDERR,
gettext("unable to determine provider name."));
goto out;
}
provname = prov->cp_name;
if (prov->cp_type != PROV_KEF_SOFT) {
cryptoerror(LOG_STDERR,
gettext("%s is not a valid kernel software provider."),
provname);
rc = FAILURE;
goto out;
}
if (getzoneid() != GLOBAL_ZONEID) {
/*
* TRANSLATION_NOTE
* "unload" could be either a literal keyword and hence
* not to be translated, or a verb and translatable.
* A choice was made to view it as a literal keyword.
* "global" is keyword and not to be translated.
*/
cryptoerror(LOG_STDERR, gettext("%1$s for kernel providers "
"is supported in the %2$s zone only"), "unload", "global");
rc = FAILURE;
goto out;
}
if (check_kernel_for_soft(provname, NULL, &in_kernel) == FAILURE) {
cryptodebug("internal error");
rc = FAILURE;
goto out;
} else if (in_kernel == B_FALSE) {
cryptoerror(LOG_STDERR,
gettext("provider %s is not loaded or does not exist."),
provname);
rc = FAILURE;
goto out;
}
/* Get kcf.conf entry. If none, build a new entry */
if ((pent = getent_kef(provname, NULL, NULL)) == NULL) {
if ((pent = create_entry(provname)) == NULL) {
cryptoerror(LOG_STDERR, gettext("out of memory."));
rc = FAILURE;
goto out;
}
}
/* If it is unloaded already, return */
if (!pent->load) { /* unloaded already */
cryptoerror(LOG_STDERR,
gettext("failed to unload %s."), provname);
rc = FAILURE;
goto out;
} else if (unload_kef_soft(provname) != FAILURE) {
/* Mark as unloaded in kcf.conf */
pent->load = B_FALSE;
rc = update_kcfconf(pent, MODIFY_MODE);
} else {
cryptoerror(LOG_STDERR,
gettext("failed to unload %s."), provname);
rc = FAILURE;
}
out:
free(prov);
free_entry(pent);
return (rc);
}
/// \brief Returns true if this program object was created as a sprite program
bool CL_ProgramObject_SWRender::is_sprite_program() const
{
return get_provider()->is_sprite_program();
}
CL_SoftwareProgram *CL_ProgramObject_SWRender::get_program() const
{
return get_provider()->get_program();
}
