4829 {
4831
4832 auto page = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
4833 page->set_hexpand(true);
4834 page->set_vexpand(true);
4835
4836 auto scrolled = Gtk::make_managed<Gtk::ScrolledWindow>();
4837 scrolled->set_policy(Gtk::PolicyType::NEVER, Gtk::PolicyType::AUTOMATIC);
4838 scrolled->set_hexpand(true);
4839 scrolled->set_vexpand(true);
4840
4841 auto outer = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 0);
4842 outer->set_margin_top(28);
4843 outer->set_margin_bottom(28);
4844 outer->set_margin_start(24);
4845 outer->set_margin_end(24);
4846 outer->set_hexpand(true);
4847 outer->set_vexpand(true);
4848
4849 auto center = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
4850 center->set_halign(Gtk::Align::CENTER);
4851 center->set_valign(Gtk::Align::START);
4852 center->set_hexpand(true);
4853 center->set_size_request(820, -1);
4854
4855 auto frame = Gtk::make_managed<Gtk::Frame>();
4856 frame->set_hexpand(true);
4857
4858 auto inner = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
4859 inner->set_margin_top(20);
4860 inner->set_margin_bottom(20);
4861 inner->set_margin_start(20);
4862 inner->set_margin_end(20);
4863
4864 auto title = Gtk::make_managed<Gtk::Label>(
_(
"Protezione Email"));
4865 title->set_halign(Gtk::Align::START);
4866 title->set_xalign(0.0f);
4867 title->add_css_class("card-title");
4868 inner->append(*title);
4869
4870 auto tabs_switcher = Gtk::make_managed<Gtk::StackSwitcher>();
4871 auto tabs = Gtk::make_managed<Gtk::Stack>();
4872 tabs->set_hexpand(true);
4873 tabs->set_vexpand(true);
4874 tabs->set_transition_type(Gtk::StackTransitionType::SLIDE_LEFT_RIGHT);
4875 tabs->set_transition_duration(250);
4876 tabs_switcher->set_stack(*tabs);
4877 tabs_switcher->set_halign(Gtk::Align::FILL);
4878 tabs_switcher->set_hexpand(true);
4879
4880 auto profiles = std::make_shared<std::vector<MailRelayProfile>>(cfg.profiles);
4881 auto selected_profile = std::make_shared<int>(0);
4882 auto ui_updating = std::make_shared<bool>(false);
4883
4884 if (profiles->empty()) {
4885 MailRelayProfile p;
4889 profiles->push_back(p);
4890 }
4891
4892 auto mkLabel = [](const Glib::ustring& text) {
4893 auto lbl = Gtk::make_managed<Gtk::Label>(text);
4894 lbl->set_halign(Gtk::Align::START);
4895 lbl->set_xalign(0.0f);
4896 return lbl;
4897 };
4898
4899 auto make_switch_row = [](const Glib::ustring& txt, Gtk::Switch& sw) {
4900 auto row = Gtk::make_managed<Gtk::CenterBox>();
4901 auto lbl = Gtk::make_managed<Gtk::Label>(txt);
4902 lbl->set_halign(Gtk::Align::START);
4903 lbl->set_xalign(0.0f);
4904 row->set_start_widget(*lbl);
4905 row->set_end_widget(sw);
4906 return row;
4907 };
4908
4909 auto tab_general = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
4910 tab_general->set_margin_top(12);
4911 tab_general->set_margin_bottom(12);
4912 tab_general->set_margin_start(12);
4913 tab_general->set_margin_end(12);
4914
4915 auto swEnable = Gtk::make_managed<Gtk::Switch>();
4916 swEnable->set_active(cfg.enabled);
4917
4918 auto swScan = Gtk::make_managed<Gtk::Switch>();
4919 swScan->set_active(cfg.scan_outgoing);
4920
4921 auto swSig = Gtk::make_managed<Gtk::Switch>();
4922 swSig->set_active(cfg.inject_signature);
4923
4924 auto swAdvertiseStartTls = Gtk::make_managed<Gtk::Switch>();
4925 swAdvertiseStartTls->set_active(cfg.advertise_starttls);
4926
4927 auto swImplicitTlsListener = Gtk::make_managed<Gtk::Switch>();
4928 swImplicitTlsListener->set_active(cfg.enable_implicit_tls_listener);
4929
4930 tab_general->append(*make_switch_row(
_(
"Abilita protezione email"), *swEnable));
4931 tab_general->append(*make_switch_row(
_(
"Scansiona email in uscita"), *swScan));
4932 tab_general->append(*make_switch_row(
_(
"Inserisci firma automatica"), *swSig));
4933 tab_general->append(*make_switch_row(
_(
"Pubblica STARTTLS"), *swAdvertiseStartTls));
4934 tab_general->append(*make_switch_row(
_(
"Abilita listener TLS implicito"), *swImplicitTlsListener));
4935
4936
4937 auto tab_signature = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
4938 tab_signature->set_margin_top(12);
4939 tab_signature->set_margin_bottom(12);
4940 tab_signature->set_margin_start(12);
4941 tab_signature->set_margin_end(12);
4942
4943 auto sName = Gtk::make_managed<Gtk::Entry>();
4944 auto sRole = Gtk::make_managed<Gtk::Entry>();
4945 auto sCompany = Gtk::make_managed<Gtk::Entry>();
4946 auto sPhone = Gtk::make_managed<Gtk::Entry>();
4947 auto sWeb = Gtk::make_managed<Gtk::Entry>();
4948
4949 auto sig_grid = Gtk::make_managed<Gtk::Grid>();
4950 sig_grid->set_row_spacing(10);
4951 sig_grid->set_column_spacing(12);
4952
4953 int sr = 0;
4954 auto attach_sig_row = [&](const Glib::ustring& lbl, Gtk::Widget& w) {
4955 sig_grid->attach(*mkLabel(lbl), 0, sr, 1, 1);
4956 sig_grid->attach(w, 1, sr, 1, 1);
4957 sr++;
4958 };
4959
4960 attach_sig_row(
_(
"Nome visualizzato"), *sName);
4961 attach_sig_row(
_(
"Ruolo"), *sRole);
4962 attach_sig_row(
_(
"Azienda"), *sCompany);
4963 attach_sig_row(
_(
"Telefono"), *sPhone);
4964 attach_sig_row(
_(
"Sito web"), *sWeb);
4965
4966 auto fixedLogoInfo = Gtk::make_managed<Gtk::Label>(
4967 _(
"Logo fisso utilizzato: /usr/share/BastionGuard/data/logo.png")
4968 );
4969 fixedLogoInfo->set_halign(Gtk::Align::START);
4970 fixedLogoInfo->set_xalign(0.0f);
4971
4972 tab_signature->append(*sig_grid);
4973 tab_signature->append(*fixedLogoInfo);
4974
4975 auto load_signature_fields = [=]() {
4976 if (profiles->empty()) return;
4977 *ui_updating = true;
4978
4979 auto& s = (*profiles)[*selected_profile].signature;
4980 sName->set_text(s.display_name);
4981 sRole->set_text(s.job_title);
4982 sCompany->set_text(s.company);
4983 sPhone->set_text(s.phone);
4984 sWeb->set_text(s.website);
4985
4986 *ui_updating = false;
4987 };
4988
4989 auto save_signature_fields = [=]() {
4990 if (profiles->empty()) return;
4991 auto& s = (*profiles)[*selected_profile].signature;
4992 s.display_name = sName->get_text();
4993 s.job_title = sRole->get_text();
4994 s.company = sCompany->get_text();
4995 s.phone = sPhone->get_text();
4996 s.website = sWeb->get_text();
4997 s.logo_path = "/usr/share/BastionGuard/data/logo.png";
4998 };
4999
5000 auto tab_thunderbird = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
5001 tab_thunderbird->set_margin_top(12);
5002 tab_thunderbird->set_margin_bottom(12);
5003 tab_thunderbird->set_margin_start(12);
5004 tab_thunderbird->set_margin_end(12);
5005
5006 auto tbInstallInfo = Gtk::make_managed<Gtk::Label>(
5007 _(
"Installa l'estensione BastionGuard per Thunderbird e il native host.\n"
5008 "Se necessario, inserisci la password amministratore per completare l'installazione.")
5009 );
5010 tbInstallInfo->set_wrap(true);
5011 tbInstallInfo->set_halign(Gtk::Align::START);
5012 tbInstallInfo->set_xalign(0.0f);
5013 tab_thunderbird->append(*tbInstallInfo);
5014
5015 auto tbInstallGrid = Gtk::make_managed<Gtk::Grid>();
5016 tbInstallGrid->set_row_spacing(10);
5017 tbInstallGrid->set_column_spacing(12);
5018
5019 int tbr = 0;
5020
5021 auto lblAdminPw = Gtk::make_managed<Gtk::Label>(
_(
"Password amministratore"));
5022 lblAdminPw->set_halign(Gtk::Align::START);
5023 lblAdminPw->set_xalign(0.0f);
5024
5025 auto eAdminPw = Gtk::make_managed<Gtk::Entry>();
5026 eAdminPw->set_visibility(false);
5027 eAdminPw->set_hexpand(true);
5028 eAdminPw->set_placeholder_text(
_(
"Inserisci la password sudo"));
5029
5030 tbInstallGrid->attach(*lblAdminPw, 0, tbr, 1, 1);
5031 tbInstallGrid->attach(*eAdminPw, 1, tbr, 1, 1);
5032 tbr++;
5033
5034 tab_thunderbird->append(*tbInstallGrid);
5035
5036 auto tbInstallButtons = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 8);
5037
5038 auto btnInstallTbExt = Gtk::make_managed<Gtk::Button>(
_(
"Installa estensione Thunderbird"));
5039 btnInstallTbExt->add_css_class("suggested-action");
5040
5041 auto btnClearTbLog = Gtk::make_managed<Gtk::Button>(
_(
"Pulisci log"));
5042
5043 tbInstallButtons->append(*btnInstallTbExt);
5044 tbInstallButtons->append(*btnClearTbLog);
5045 tab_thunderbird->append(*tbInstallButtons);
5046
5047 auto tbInstallOutput = Gtk::make_managed<Gtk::TextView>();
5048 tbInstallOutput->set_editable(false);
5049 tbInstallOutput->set_cursor_visible(false);
5050 tbInstallOutput->set_monospace(true);
5051 tbInstallOutput->set_wrap_mode(Gtk::WrapMode::WORD_CHAR);
5052 tbInstallOutput->set_vexpand(true);
5053
5054 auto tbInstallBuffer = Gtk::TextBuffer::create();
5055 tbInstallOutput->set_buffer(tbInstallBuffer);
5056
5057 auto tbInstallScroll = Gtk::make_managed<Gtk::ScrolledWindow>();
5058 tbInstallScroll->set_policy(Gtk::PolicyType::AUTOMATIC, Gtk::PolicyType::AUTOMATIC);
5059 tbInstallScroll->set_min_content_height(260);
5060 tbInstallScroll->set_child(*tbInstallOutput);
5061 tab_thunderbird->append(*tbInstallScroll);
5062
5063 btnClearTbLog->signal_clicked().connect([=]() {
5064 tbInstallBuffer->set_text("");
5065 });
5066
5067 auto run_tb_installer = [=]() {
5068 const std::string script_path =
5069 "/usr/share/BastionGuard/data/extension/bastionguard-tb-extension/install-tb-extension.sh";
5070
5071 tbInstallBuffer->set_text("");
5072
5073 if (!Glib::file_test(script_path, Glib::FileTest::IS_REGULAR)) {
5074 tbInstallBuffer->set_text(
5075 _(
"Script non trovato:\n") + Glib::ustring(script_path) +
"\n"
5076 );
5077 return;
5078 }
5079
5080 const std::string password = std::string(eAdminPw->get_text());
5081
5082
5083
5085 8U * 1024U * 1024U, {{"BASTIONGUARD_SUDO_PASSWORD", password}});
5086 if (!install.started) {
5087 tbInstallBuffer->set_text(
_(
"Impossibile avviare lo script di installazione.\n"));
5088 return;
5089 }
5090 const std::string& output = install.
output;
5091 const int exit_code = install.exit_code;
5092
5093 if (exit_code == 0) {
5094 tbInstallBuffer->insert(
5095 tbInstallBuffer->end(),
5096 _(
"\n✔ Installazione Thunderbird completata.\n")
5097 );
5098 } else {
5099 tbInstallBuffer->insert(
5100 tbInstallBuffer->end(),
5101 Glib::ustring::compose(
_(
"\n❌ Installazione fallita (exit=%1)\n"), exit_code)
5102 );
5103 }
5104 };
5105
5106 btnInstallTbExt->signal_clicked().connect([=]() {
5107 run_tb_installer();
5108 });
5109
5110
5111 auto tab_profiles = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 12);
5112 tab_profiles->set_margin_top(12);
5113 tab_profiles->set_margin_bottom(12);
5114 tab_profiles->set_margin_start(12);
5115 tab_profiles->set_margin_end(12);
5116
5117 auto lbl_profiles_info = Gtk::make_managed<Gtk::Label>(
5118 _(
"Seleziona i profili SMTP da importare da Thunderbird.\n"
5119 "Le password non sono esportabili: dovrai inserirle manualmente dopo l'importazione.")
5120 );
5121 lbl_profiles_info->set_wrap(true);
5122 lbl_profiles_info->set_halign(Gtk::Align::START);
5123 lbl_profiles_info->add_css_class("alert-info");
5124 tab_profiles->append(*lbl_profiles_info);
5125
5126 auto tb_status = Gtk::make_managed<Gtk::Label>();
5127 tb_status->set_halign(Gtk::Align::START);
5128 tb_status->add_css_class("status-muted");
5129 tab_profiles->append(*tb_status);
5130
5131 auto tb_list_frame = Gtk::make_managed<Gtk::Frame>(
_(
"Profili trovati in Thunderbird"));
5132 auto tb_list_box = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 6);
5133 tb_list_box->set_margin(8);
5134 tb_list_frame->set_child(*tb_list_box);
5135 tab_profiles->append(*tb_list_frame);
5136
5137 auto tb_found = std::make_shared<std::vector<MailRelayProfile>>();
5138 auto tb_selected = std::make_shared<std::vector<Gtk::CheckButton*>>();
5139
5140 using PwEntriesPtr = std::shared_ptr<std::vector<Gtk::Entry*>>;
5141 auto tb_pw_entries_ref = std::make_shared<PwEntriesPtr>();
5142
5143 using HostEntriesPtr = std::shared_ptr<std::vector<Gtk::Entry*>>;
5144 auto tb_host_entries_ref = std::make_shared<HostEntriesPtr>();
5145
5146 using PortSpinsPtr = std::shared_ptr<std::vector<Gtk::SpinButton*>>;
5147 auto tb_port_spins_ref = std::make_shared<PortSpinsPtr>();
5148
5149 auto populate_profile_list = [=](const std::vector<MailRelayProfile>& source_profiles,
5150 bool from_json) {
5151 for (auto* w : tb_list_box->get_children())
5152 tb_list_box->remove(*w);
5153
5154 tb_found->clear();
5155 tb_selected->clear();
5156
5157 auto tb_pw_entries = std::make_shared<std::vector<Gtk::Entry*>>();
5158 auto tb_host_entries = std::make_shared<std::vector<Gtk::Entry*>>();
5159 auto tb_port_spins = std::make_shared<std::vector<Gtk::SpinButton*>>();
5160
5161 for (size_t i = 0; i < source_profiles.size(); ++i) {
5162 const auto& p = source_profiles[i];
5163 tb_found->push_back(p);
5164
5165 auto row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::VERTICAL, 4);
5166 row->set_margin_bottom(10);
5167
5168 if (i == 0 && from_json) {
5169 auto sep_lbl = Gtk::make_managed<Gtk::Label>(
_(
"Profili attivi (da mail.json)"));
5170 sep_lbl->set_halign(Gtk::Align::START);
5171 sep_lbl->add_css_class("caption");
5172 sep_lbl->add_css_class("status-muted");
5173 tb_list_box->append(*sep_lbl);
5174 }
5175
5177 auto cb = Gtk::make_managed<Gtk::CheckButton>(title);
5178 cb->set_active(true);
5179 if (from_json)
5180 cb->set_sensitive(false);
5181 row->append(*cb);
5182
5183 std::string emails;
5184 for (
size_t j = 0; j < p.
match_from.size(); ++j) {
5185 if (j) emails += ", ";
5187 }
5188
5189 if (!emails.empty()) {
5190 auto lbl_emails = Gtk::make_managed<Gtk::Label>(
5191 " " + std::string(
_(
"Email: ")) + emails);
5192 lbl_emails->set_halign(Gtk::Align::START);
5193 lbl_emails->set_xalign(0.0f);
5194 lbl_emails->add_css_class("status-muted");
5195 row->append(*lbl_emails);
5196 }
5197
5198 const bool host_is_local = (
5204 );
5205
5206 if (host_is_local && !from_json) {
5207 auto lbl_warn = Gtk::make_managed<Gtk::Label>(
5208 "⚠ " + std::string(
_(
"smtp_host non valido — inserisci il server SMTP reale")));
5209 lbl_warn->set_halign(Gtk::Align::START);
5210 lbl_warn->set_margin_start(24);
5211 lbl_warn->add_css_class("alert-warning");
5212 row->append(*lbl_warn);
5213 }
5214
5215 auto host_row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
5216 host_row->set_margin_start(24);
5217
5218 auto lbl_host = Gtk::make_managed<Gtk::Label>(
_(
"Server SMTP:"));
5219 lbl_host->set_halign(Gtk::Align::START);
5220 lbl_host->set_size_request(100, -1);
5221
5222 auto host_entry = Gtk::make_managed<Gtk::Entry>();
5223 host_entry->set_text(host_is_local ?
"" : p.
smtp_host);
5224 host_entry->set_placeholder_text(
_(
"es. mail.esempio.it"));
5225 host_entry->set_hexpand(true);
5226
5227 if (host_is_local && !from_json)
5228 host_entry->add_css_class("entry-error");
5229
5230 if (from_json)
5231 host_entry->set_sensitive(!p.
smtp_host.empty());
5232
5233 host_row->append(*lbl_host);
5234 host_row->append(*host_entry);
5235
5236 auto lbl_port = Gtk::make_managed<Gtk::Label>(
_(
"Porta:"));
5237 lbl_port->set_halign(Gtk::Align::START);
5238
5239 auto port_spin = Gtk::make_managed<Gtk::SpinButton>();
5240 port_spin->set_range(1, 65535);
5241 port_spin->set_increments(1, 10);
5243 port_spin->set_size_request(90, -1);
5244
5245 if (from_json)
5246 port_spin->set_sensitive(false);
5247
5248 host_row->append(*lbl_port);
5249 host_row->append(*port_spin);
5250 row->append(*host_row);
5251
5252 auto pw_row = Gtk::make_managed<Gtk::Box>(Gtk::Orientation::HORIZONTAL, 6);
5253 pw_row->set_margin_start(24);
5254
5255 auto lbl_pw_label = Gtk::make_managed<Gtk::Label>(
_(
"Password:"));
5256 lbl_pw_label->set_halign(Gtk::Align::START);
5257 lbl_pw_label->set_size_request(100, -1);
5258
5259 auto pw_entry = Gtk::make_managed<Gtk::Entry>();
5260 pw_entry->set_visibility(false);
5261 pw_entry->set_placeholder_text(
5262 from_json ?
_(
"(salvata)") :
_(
"Inserisci la password SMTP")
5263 );
5264 pw_entry->set_hexpand(true);
5265
5266 for (const auto& existing : *profiles) {
5267 if ((existing.id == p.
id || existing.smtp_host == p.
smtp_host) &&
5268 !existing.password.empty() &&
5269 existing.password != "placeholder") {
5270 pw_entry->set_text(existing.password);
5271 break;
5272 }
5273 }
5274
5275 pw_row->append(*lbl_pw_label);
5276 pw_row->append(*pw_entry);
5277 row->append(*pw_row);
5278
5279 tb_list_box->append(*row);
5280 tb_selected->push_back(cb);
5281 tb_pw_entries->push_back(pw_entry);
5282 tb_host_entries->push_back(host_entry);
5283 tb_port_spins->push_back(port_spin);
5284 }
5285
5286 *tb_pw_entries_ref = tb_pw_entries;
5287 *tb_host_entries_ref = tb_host_entries;
5288 *tb_port_spins_ref = tb_port_spins;
5289 };
5290
5291 {
5293 if (!existing_cfg.profiles.empty()) {
5294 tb_status->set_text(Glib::ustring::compose(
5295 _(
"✔ %1 profili attivi"), (
int)existing_cfg.profiles.size()));
5296 populate_profile_list(existing_cfg.profiles, true);
5297 }
5298 }
5299
5300 auto btn_scan_tb = Gtk::make_managed<Gtk::Button>(
_(
"🔍 Scansiona Thunderbird"));
5301 btn_scan_tb->add_css_class("suggested-action");
5302 tab_profiles->append(*btn_scan_tb);
5303
5304 btn_scan_tb->signal_clicked().connect([=]() {
5305 std::string err;
5307
5308 if (scanned.empty()) {
5309 tb_status->set_text("❌ " + (err.empty()
5310 ? std::string(
_(
"Nessun profilo trovato"))
5311 : err));
5312 return;
5313 }
5314
5315 tb_status->set_text(Glib::ustring::compose(
5316 _(
"✔ Trovati %1 profili SMTP da Thunderbird"), (
int)scanned.size()));
5317
5318 populate_profile_list(scanned, false);
5319 });
5320
5321 auto btn_import_tb = Gtk::make_managed<Gtk::Button>(
_(
"⬇ Importa profili selezionati"));
5322 tab_profiles->append(*btn_import_tb);
5323
5324 btn_import_tb->signal_clicked().connect([=]() {
5325 if (tb_found->empty()) {
5326 tb_status->set_text(
_(
"❌ Nessun profilo da importare. Scansiona prima."));
5327 return;
5328 }
5329
5330 int imported = 0;
5331 auto& pw_entries = *tb_pw_entries_ref;
5332
5333 for (size_t i = 0; i < tb_found->size() && i < tb_selected->size(); ++i) {
5334 if (!(*tb_selected)[i]->get_active())
5335 continue;
5336
5337 MailRelayProfile src = (*tb_found)[i];
5338
5339 if (pw_entries && i < pw_entries->size()) {
5340 std::string pw = std::string((*pw_entries)[i]->get_text());
5341 if (!pw.empty())
5343 }
5344
5345 auto& host_entries = *tb_host_entries_ref;
5346 auto& port_spins = *tb_port_spins_ref;
5347
5348 if (host_entries && i < host_entries->size()) {
5349 std::string h = std::string((*host_entries)[i]->get_text());
5350 auto start = h.find_first_not_of(" \t");
5351 if (start == std::string::npos) {
5352 h.clear();
5353 } else {
5354 auto end = h.find_last_not_of(" \t");
5355 h = h.substr(start, end - start + 1);
5356 }
5357 if (!h.empty())
5359 }
5360
5361 if (port_spins && i < port_spins->size()) {
5362 int pt = (*port_spins)[i]->get_value_as_int();
5363 if (pt > 0 && pt < 65536)
5365 }
5366
5367 bool found = false;
5368 for (auto& existing : *profiles) {
5369 if (existing.id == src.
id || existing.smtp_host == src.
smtp_host) {
5370 existing = src;
5371 found = true;
5372 break;
5373 }
5374 }
5375
5376 if (!found) {
5377 profiles->push_back(src);
5378 if (profiles->size() == 1)
5379 *selected_profile = 0;
5380 }
5381
5382 ++imported;
5383 }
5384
5385 if (imported > 0) {
5388
5390 bool found = false;
5391 for (
const auto& p : auto_save.
profiles) {
5393 found = true;
5394 break;
5395 }
5396 }
5397 if (!found && !auto_save.
profiles.empty())
5399 }
else if (!auto_save.
profiles.empty()) {
5401 }
5402
5404 (
bg_process::run({
"/usr/libexec/bastionguard/bastionguard-service",
"--user",
"restart",
"BastionGuard-mailproxy.service"}).exit_code);
5405 tb_status->set_text(Glib::ustring::compose(
5406 _(
"✔ %1 profili salvati e proxy riavviato."),
5408 } else {
5409 tb_status->set_text(Glib::ustring::compose(
5410 _(
"✔ Importati %1 profili — salvataggio fallito, usa 'Salva' manualmente."),
5411 imported));
5412 }
5413
5414 load_signature_fields();
5415
5417 populate_profile_list(
5418 refreshed.profiles.empty() ? *profiles : refreshed.profiles,
5419 true);
5420 } else {
5421 tb_status->set_text(
_(
"Nessun profilo selezionato."));
5422 }
5423 });
5424
5425 tabs->add(*tab_general,
"general",
_(
"Generale"));
5426 tabs->add(*tab_signature,
"signature",
_(
"Firma"));
5427 tabs->add(*tab_profiles,
"smtp-profiles",
_(
"Profili SMTP"));
5428 tabs->add(*tab_thunderbird,
"thunderbird",
_(
"Thunderbird"));
5429
5430 inner->append(*tabs_switcher);
5431 inner->append(*tabs);
5432
5433 auto status = Gtk::make_managed<Gtk::Label>();
5434 status->set_halign(Gtk::Align::START);
5435 status->set_xalign(0.0f);
5436 status->add_css_class("status-muted");
5437 inner->append(*status);
5438
5439 auto btnSave = Gtk::make_managed<Gtk::Button>(
_(
"Salva configurazione email"));
5440 btnSave->add_css_class("suggested-action");
5441 btnSave->set_halign(Gtk::Align::START);
5442 inner->append(*btnSave);
5443
5444 btnSave->signal_clicked().connect([=]() {
5445 if (*ui_updating)
5446 return;
5447
5448 save_signature_fields();
5449
5450 MailSecurityConfig out;
5452 out.
enabled = swEnable->get_active();
5455 out.
local_host = cfg.local_host.empty() ?
"127.0.0.1" : cfg.local_host;
5456 out.
local_port = cfg.local_port > 0 ? cfg.local_port : 2525;
5457 out.
local_tls_port = cfg.local_tls_port > 0 ? cfg.local_tls_port : 2465;
5461
5462 MailSignatureConfig sig_ui;
5465 sig_ui.
company = sCompany->get_text();
5466 sig_ui.
phone = sPhone->get_text();
5467 sig_ui.
website = sWeb->get_text();
5468 sig_ui.
logo_path =
"/usr/share/BastionGuard/data/logo.png";
5469
5474 sig_ui.
phone.empty() &&
5476 auto dlg = Gtk::AlertDialog::create(
_(
"Firma vuota"));
5477 dlg->set_detail(
_(
"La firma automatica è abilitata ma tutti i campi firma sono vuoti."));
5478 dlg->show();
5479 return;
5480 }
5481 }
5482
5484
5486 MailRelayProfile p;
5487 p.
id =
"bastionguard";
5488 p.
label =
"BastionGuard";
5492 } else {
5495
5496 std::vector<std::string> loop_profiles;
5499 if (h == "127.0.0.1" || h == "127.0.0.4" || h == "::1" || h == "localhost") {
5500 loop_profiles.push_back(p.
label.empty() ? p.
id : p.
label);
5502 }
5503 }
5504
5505 if (!loop_profiles.empty()) {
5506 std::string names;
5507 for (const auto& n : loop_profiles)
5508 names += "• " + n + "\n";
5509
5510 auto dlg = Gtk::AlertDialog::create(
_(
"Profili SMTP non configurati"));
5511 dlg->set_detail(
5512 _(
"I seguenti profili avevano smtp_host = 127.0.0.1 e non possono essere usati come relay:\n") +
5513 names +
5514 _(
"\nSono stati salvati senza server SMTP. Aggiorna i campi 'Server SMTP' nel tab Profili SMTP e reimporta.")
5515 );
5516 dlg->show();
5517 }
5518
5519 bool def_found = false;
5520 for (
const auto& p : out.
profiles) {
5522 def_found = true;
5523 break;
5524 }
5525 }
5526 if (!def_found)
5528 }
5529
5531 status->set_text(
_(
"❌ Impossibile salvare la configurazione"));
5532 auto dlg = Gtk::AlertDialog::create(
_(
"Errore salvataggio"));
5533 dlg->set_detail(
_(
"Impossibile scrivere ~/.config/BastionGuard/mail.json"));
5534 dlg->show();
5535 return;
5536 }
5537
5538 (
bg_process::run({
"/usr/libexec/bastionguard/bastionguard-service",
"--user",
"restart",
"BastionGuard-mailproxy.service"}).exit_code);
5539
5540 status->set_text(
_(
"✔ Configurazione salvata in ~/.config/BastionGuard/mail.json"));
5541
5542 populate_profile_list(out.
profiles,
true);
5543 tb_status->set_text(Glib::ustring::compose(
5544 _(
"✔ %1 profili attivi"), (
int)out.
profiles.size()));
5545 });
5546
5547 load_signature_fields();
5548
5549 frame->set_child(*inner);
5550 center->append(*frame);
5551 outer->append(*center);
5552 scrolled->set_child(*outer);
5553 page->append(*scrolled);
5554
5556 stack.add(*page,
"email",
_(
"Email"));
5557}
static bool save_mail_security_config(const MailSecurityConfig &cfg)
static MailSecurityConfig load_mail_security_config()
static std::vector< MailRelayProfile > tb_import_profiles(std::string &err_out)
MailSignatureConfig signature
std::vector< std::string > match_from
bool enable_implicit_tls_listener
std::string default_profile_id
int local_submission_port
std::vector< MailRelayProfile > profiles
