1471 lines
57 KiB
Python
Executable File
1471 lines
57 KiB
Python
Executable File
#!/usr/bin/python3
|
|
|
|
import gettext
|
|
import locale
|
|
import webbrowser
|
|
import os
|
|
import sys
|
|
import signal
|
|
import subprocess
|
|
import shutil
|
|
import tkinter as tk
|
|
from pathlib import Path
|
|
from subprocess import check_call
|
|
from tkinter import filedialog, ttk, TclError
|
|
from cls_mth_fc import Tunnel, Create, msg_window, Tipi, GiteaUpdate, UOS
|
|
|
|
UOS.username()
|
|
Create.dir_and_files()
|
|
Create.make_dir()
|
|
Create.decrypt()
|
|
|
|
tcl_path = Path("/usr/share/TK-Themes")
|
|
wg_set = Path(Path.home() / ".config/wire_py/settings")
|
|
wg_tips = Tipi.if_tip(wg_set)
|
|
dirname = Path("/tmp/tlecdcwg/")
|
|
|
|
""" 1 = 1. Year, 09 = Month of the Year, 2924 = Day and Year of the Year """
|
|
version = "v. 2.04.1725"
|
|
|
|
res = GiteaUpdate.api_down(
|
|
"https://git.ilunix.de/api/v1/repos/punix/Wire-Py/releases", version
|
|
)
|
|
|
|
""" Translate """
|
|
APP = "wirepy"
|
|
LOCALE_DIR = "/usr/share/locale/"
|
|
locale.bindtextdomain(APP, LOCALE_DIR)
|
|
gettext.bindtextdomain(APP, LOCALE_DIR)
|
|
gettext.textdomain(APP)
|
|
_ = gettext.gettext
|
|
|
|
|
|
def signalHandler(signum, frame):
|
|
"""Determine clear text names for signal numbers"""
|
|
SIGNALS_TO_NAMES_DICT = dict(
|
|
(getattr(signal, n), n)
|
|
for n in dir(signal)
|
|
if n.startswith("SIG") and "_" not in n
|
|
)
|
|
signame = SIGNALS_TO_NAMES_DICT.get(signum, "Unnamed signal: %d" % signum)
|
|
|
|
"""
|
|
End program for certain signals,
|
|
report to others only reception
|
|
"""
|
|
if signum in (signal.SIGINT, signal.SIGTERM):
|
|
exitCode = 1
|
|
print(
|
|
"\nSignal '%s' (%d) received. => Aborting with exit code %d."
|
|
% (signame, signum, exitCode)
|
|
)
|
|
shutil.rmtree(dirname)
|
|
Path.unlink("/tmp/.loguser")
|
|
print("Breakdown by user...")
|
|
sys.exit(exitCode)
|
|
else:
|
|
print("Signal %d received and ignored." % signum)
|
|
shutil.rmtree(dirname)
|
|
Path.unlink("/tmp/.loguser")
|
|
print("Process unexpectedly ended...")
|
|
|
|
|
|
signal.signal(signal.SIGINT, signalHandler)
|
|
signal.signal(signal.SIGTERM, signalHandler)
|
|
signal.signal(signal.SIGHUP, signalHandler)
|
|
|
|
|
|
class Wirepy(tk.Tk):
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
|
|
self.my_tool_tip = None
|
|
self.x_width = 600
|
|
self.y_height = 383
|
|
self.monitor_center_x = self.winfo_screenwidth() / 2 - (self.x_width / 2)
|
|
self.monitor_center_y = self.winfo_screenheight() / 2 - (self.y_height / 2)
|
|
self.resizable(width=False, height=False)
|
|
self.title("Wire-Py")
|
|
self.geometry(
|
|
"%dx%d+%d+%d"
|
|
% (
|
|
self.x_width,
|
|
self.y_height,
|
|
self.monitor_center_x,
|
|
self.monitor_center_y,
|
|
)
|
|
)
|
|
self.columnconfigure(0, weight=1)
|
|
self.rowconfigure(0, weight=1)
|
|
|
|
self.style = ttk.Style(self)
|
|
self.tk.call("source", str(tcl_path) + "/water.tcl")
|
|
""" self.tk.call('source', 'TK-Themes/water.tcl') """
|
|
with open(wg_set, "r") as read_file:
|
|
lines = read_file.readlines()
|
|
if "light\n" in lines:
|
|
self.tk.call("set_theme", "light")
|
|
else:
|
|
self.tk.call("set_theme", "dark")
|
|
|
|
""" Load the image file from disk. """
|
|
self.wg_icon = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/48/wg_vpn.png")
|
|
|
|
""" Set it as the window icon """
|
|
self.iconphoto(True, self.wg_icon)
|
|
|
|
FrameWidgets(self).grid()
|
|
|
|
|
|
class FrameWidgets(ttk.Frame):
|
|
def __init__(self, container, **kwargs):
|
|
super().__init__(container, **kwargs)
|
|
|
|
self.lb_tunnel = None
|
|
self.btn_stst = None
|
|
self.endpoint = None
|
|
self.dns = None
|
|
self.address = None
|
|
self.auto_con = None
|
|
self.wg_vpn_start = tk.PhotoImage(
|
|
file=r"/usr/share/icons/lx-icons/48/wg_vpn-start.png"
|
|
)
|
|
self.wg_vpn_stop = tk.PhotoImage(
|
|
file=r"/usr/share/icons/lx-icons/48/wg_vpn-stop.png"
|
|
)
|
|
self.imp_pic = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/48/wg_import.png")
|
|
self.tr_pic = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/48/wg_trash.png")
|
|
self.exp_pic = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/48/wg_export.png")
|
|
self.warning_pic = tk.PhotoImage(file=r"/usr/share/icons/lx-icons/64/error.png")
|
|
self.wg_vpn_start = tk.PhotoImage(
|
|
file=r"/usr/share/icons/lx-icons/48/wg_vpn-start.png"
|
|
)
|
|
self.wg_vpn_stop = tk.PhotoImage(
|
|
file=r"/usr/share/icons/lx-icons/48/wg_vpn-stop.png"
|
|
)
|
|
|
|
""" Set on or off in file """
|
|
|
|
def update():
|
|
if set_update.get() == 1:
|
|
with open(wg_set, "r") as set_file2:
|
|
lines2 = set_file2.readlines()
|
|
lines2[1] = "off\n"
|
|
with open(wg_set, "w") as set_file2:
|
|
set_file2.writelines(lines2)
|
|
|
|
if set_update.get() == 0:
|
|
with open(wg_set, "r") as set_file2:
|
|
lines2 = set_file2.readlines()
|
|
lines2[1] = "on\n"
|
|
with open(wg_set, "w") as set_file2:
|
|
set_file2.writelines(lines2)
|
|
|
|
""" Set True or False in file """
|
|
|
|
def tooltip():
|
|
if set_tip.get():
|
|
with open(wg_set, "r") as set_file2:
|
|
lines2 = set_file2.readlines()
|
|
lines2[5] = "False\n"
|
|
with open(wg_set, "w") as set_file2:
|
|
set_file2.writelines(lines2)
|
|
|
|
else:
|
|
with open(wg_set, "r") as set_file2:
|
|
lines2 = set_file2.readlines()
|
|
lines2[5] = "True\n"
|
|
with open(wg_set, "w") as set_file2:
|
|
set_file2.writelines(lines2)
|
|
|
|
""" Set dark or light """
|
|
|
|
def theme_change_light():
|
|
if self.tk.call("ttk::style", "theme", "use") == "water-dark":
|
|
"""Set light theme"""
|
|
self.tk.call("set_theme", "light")
|
|
with open(wg_set, "r") as theme_set2:
|
|
lines3 = theme_set2.readlines()
|
|
lines3[3] = "light\n"
|
|
with open(wg_set, "w") as theme_set2:
|
|
theme_set2.writelines(lines3)
|
|
self.color_label()
|
|
|
|
def theme_change_dark():
|
|
if not self.tk.call("ttk::style", "theme", "use") == "water-dark":
|
|
"""Set dark theme"""
|
|
self.tk.call("set_theme", "dark")
|
|
with open(wg_set, "r") as theme_set2:
|
|
lines4 = theme_set2.readlines()
|
|
lines4[3] = "dark\n"
|
|
with open(wg_set, "w") as theme_set2:
|
|
theme_set2.writelines(lines4)
|
|
self.color_label()
|
|
|
|
def info():
|
|
def link_btn():
|
|
webbrowser.open("https://git.ilunix.de/punix/Wire-Py")
|
|
|
|
""" img_w, img_i, w_title, w_txt , txt2, com hand over """
|
|
iw = r"/usr/share/icons/lx-icons/48/wg_vpn.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Info")
|
|
msg_t = _(
|
|
"Wire-Py a simple Wireguard Gui for Linux systems.\n\n"
|
|
"Wire-Py is open source software written in Python.\n\n"
|
|
"Email: polunga40@unity-mail.de also likes for donation.\n\n"
|
|
"Use without warranty!\n"
|
|
)
|
|
txt2 = _("Go to Wire-Py git")
|
|
com = link_btn
|
|
|
|
msg_window(iw, ii, wt, msg_t, txt2, com)
|
|
|
|
""" Frame for Menu """
|
|
self.menu_frame = ttk.Frame(self)
|
|
self.menu_frame.configure(relief="flat")
|
|
self.menu_frame.grid(column=0, row=0, columnspan=4, sticky="w")
|
|
|
|
""" App Menu """
|
|
self.version_lb = ttk.Label(self.menu_frame, text=version)
|
|
self.version_lb.config(font=("Ubuntu", 11), foreground="#00c4ff")
|
|
self.version_lb.grid(column=0, row=0, rowspan=4, padx=10)
|
|
|
|
def version_enter(event):
|
|
"""The mouse moves into the Version widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, f"Version: {version[2:]}"
|
|
)
|
|
|
|
def version_leave(_):
|
|
"""The mouse moves from the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.options_btn = ttk.Menubutton(self.menu_frame, text=_("Options"))
|
|
self.options_btn.grid(column=1, columnspan=1, row=0)
|
|
|
|
def sets_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("Click for Settings")
|
|
)
|
|
|
|
def sets_leave(_):
|
|
"""The mouse moves from the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.version_lb.bind("<Enter>", version_enter)
|
|
self.version_lb.bind("<Leave>", version_leave)
|
|
self.options_btn.bind("<Enter>", sets_enter)
|
|
self.options_btn.bind("<Leave>", sets_leave)
|
|
|
|
set_update = tk.IntVar()
|
|
set_tip = tk.BooleanVar()
|
|
self.settings = tk.Menu(self, relief="flat")
|
|
self.options_btn.configure(menu=self.settings, style="Toolbutton")
|
|
self.settings.add_checkbutton(
|
|
label=_("Disable Updates"), command=update, variable=set_update
|
|
)
|
|
self.settings.add_checkbutton(
|
|
label=_("Disable Tooltips"), command=tooltip, variable=set_tip
|
|
)
|
|
self.settings.add_command(label=_("Light"), command=theme_change_light)
|
|
self.settings.add_command(label=_("Dark"), command=theme_change_dark)
|
|
|
|
""" About BTN Menu / Label """
|
|
self.about_btn = ttk.Button(
|
|
self.menu_frame, text=_("About"), style="Toolbutton", command=info
|
|
)
|
|
self.about_btn.grid(column=2, columnspan=2, row=0)
|
|
self.readme = tk.Menu(self)
|
|
|
|
""" Update and Tooltip Label """
|
|
self.updates_lb = ttk.Label(self.menu_frame)
|
|
self.updates_lb.grid(column=4, columnspan=3, row=0, padx=10)
|
|
"""View Checkbox for enable or disable Tooltip """
|
|
if wg_tips:
|
|
set_tip.set(value=False)
|
|
else:
|
|
set_tip.set(value=True)
|
|
|
|
"""View Checkbox for enable or disable Updates """
|
|
if res == "False":
|
|
set_update.set(value=1)
|
|
self.updates_lb.configure(text=_("Update search off"))
|
|
|
|
def disable_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("Updates you have disabled")
|
|
)
|
|
|
|
def disable_leave(_):
|
|
"""The mouse moves from the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.updates_lb.bind("<Enter>", disable_enter)
|
|
self.updates_lb.bind("<Leave>", disable_leave)
|
|
elif res == "No Internet Connection!":
|
|
self.updates_lb.configure(text=_("No Server Connection!"), foreground="red")
|
|
elif res == "No Updates":
|
|
self.updates_lb.configure(text=_("No Updates"))
|
|
|
|
def congratulations_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("Congratulations! Wire-Py is up to date"),
|
|
)
|
|
|
|
def congratulations_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.updates_lb.bind("<Enter>", congratulations_enter)
|
|
self.updates_lb.bind("<Leave>", congratulations_leave)
|
|
else:
|
|
set_update.set(value=0)
|
|
text = f"Update {res} " + _("available!")
|
|
|
|
""" Update BTN Menu"""
|
|
self.update_btn = ttk.Menubutton(self.menu_frame, text=text)
|
|
self.update_btn.grid(column=4, columnspan=3, row=0, padx=0)
|
|
|
|
def download_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("Click to download new version")
|
|
)
|
|
|
|
def download_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.update_btn.bind("<Enter>", download_enter)
|
|
self.update_btn.bind("<Leave>", download_leave)
|
|
|
|
self.download = tk.Menu(self, relief="flat")
|
|
|
|
self.update_btn.configure(menu=self.download, style="Toolbutton")
|
|
self.download.add_command(
|
|
label=_("Download"),
|
|
command=lambda: GiteaUpdate.download(
|
|
f"https://git.ilunix.de/punix" f"/Wire-Py/archive/" f"{res}.zip",
|
|
r"/usr/" r"share/icons/lx-icons" r"/48/wg_vpn.png",
|
|
r"/usr/share/icons/lx-icons" r"/48/wg_msg.png",
|
|
res,
|
|
),
|
|
)
|
|
|
|
""" Show active Tunnel """
|
|
self.a = Tunnel.active()
|
|
|
|
""" Label Frame 1 """
|
|
self.lb_frame_btn_lbox = ttk.Frame(self)
|
|
self.lb_frame_btn_lbox.configure(relief="flat")
|
|
self.lb_frame_btn_lbox.grid(column=0, rowspan=3, row=1)
|
|
|
|
""" Label Frame 2 """
|
|
self.lb_frame = ttk.Frame(self)
|
|
self.lb_frame.configure(relief="solid")
|
|
self.lb_frame.grid(column=2, row=2, sticky="snew", padx=20, pady=5)
|
|
|
|
""" Label Frame 3 """
|
|
self.lb_frame2 = ttk.Frame(self)
|
|
self.lb_frame2.configure(relief="solid")
|
|
self.lb_frame2.grid(column=2, row=3, sticky="snew", padx=20, pady=5)
|
|
|
|
""" Bottom Frame 4 """
|
|
self.lb_frame3 = ttk.Frame(self)
|
|
self.lb_frame3.configure(relief="flat")
|
|
self.lb_frame3.grid(
|
|
column=0, row=5, columnspan=4, sticky="snew", padx=2, pady=2
|
|
)
|
|
|
|
""" Bottom Frame 5 """
|
|
self.lb_frame4 = ttk.Frame(self)
|
|
self.lb_frame4.configure(relief="flat")
|
|
self.lb_frame4.grid(column=2, row=5, columnspan=3, sticky="e", padx=15)
|
|
|
|
""" Show active Label """
|
|
self.select_tunnel = None
|
|
self.lb = ttk.Label(self, text=_("Active: "))
|
|
self.lb.config(font=("Ubuntu", 11, "bold"))
|
|
self.lb.grid(column=2, row=1, padx=15, pady=4, sticky="w")
|
|
|
|
""" Label to Show active Tunnel """
|
|
self.StrVar = tk.StringVar(value=self.a)
|
|
self.color_label()
|
|
|
|
""" Interface Label """
|
|
self.interface = ttk.Label(self.lb_frame, text=_("Interface"))
|
|
self.interface.grid(column=0, row=3, sticky="we", padx=120)
|
|
self.interface.config(font=("Ubuntu", 9))
|
|
|
|
""" Peer Label """
|
|
self.peer = ttk.Label(self.lb_frame2, text=_("Peer"))
|
|
self.peer.config(font=("Ubuntu", 9))
|
|
self.peer.grid(column=0, row=4, sticky="we", padx=130)
|
|
|
|
""" Listbox with Scrollbar """
|
|
|
|
def enable_check_box(_):
|
|
Create.files_for_autostart()
|
|
if self.l_box.size() != 0:
|
|
self.wg_autostart.configure(state="normal")
|
|
self.lb_rename.config(state="normal")
|
|
self.lb_rename.delete(0, tk.END)
|
|
self.btn_rename.config(state="normal")
|
|
|
|
self.l_box = tk.Listbox(self.lb_frame_btn_lbox, selectmode="single")
|
|
self.l_box.config(relief="ridge", font=("Ubuntu", 12, "bold"))
|
|
self.l_box.grid(column=1, rowspan=4, row=0, sticky="ns")
|
|
self.l_box.event_add("<<ClickEvent>>", "<Button-1>")
|
|
self.l_box.bind("<<ClickEvent>>", enable_check_box)
|
|
self.scrollbar = ttk.Scrollbar(
|
|
self.lb_frame_btn_lbox, orient="vertical", command=self.l_box.yview
|
|
)
|
|
self.scrollbar.grid(column=1, rowspan=4, row=0, sticky="nse")
|
|
self.l_box.configure(yscrollcommand=self.scrollbar.set)
|
|
|
|
""" Tunnel List """
|
|
|
|
self.tl = Tunnel.list()
|
|
for tunnels in self.tl:
|
|
self.l_box.insert("end", tunnels[:-5])
|
|
self.l_box.update()
|
|
|
|
def list_empty_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("You must first import\na Wireguard tunnel"),
|
|
)
|
|
|
|
def list_empty_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def list_not_empty_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("Select a Tunnel")
|
|
)
|
|
|
|
def list_not_empty_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
if self.l_box.size() == 0:
|
|
self.l_box.bind("<Enter>", list_empty_enter)
|
|
self.l_box.bind("<Leave>", list_empty_leave)
|
|
else:
|
|
self.l_box.bind("<Enter>", list_not_empty_enter)
|
|
self.l_box.bind("<Leave>", list_not_empty_leave)
|
|
|
|
""" Button Vpn """
|
|
if self.a != "":
|
|
self.stop()
|
|
wg_read = "/tmp/tlecdcwg/" + str(self.a + ".conf")
|
|
with open(wg_read, "r") as file:
|
|
data = Tunnel.con_to_dict(file)
|
|
|
|
""" Address Label """
|
|
self.init_and_report(data)
|
|
self.show_data()
|
|
else:
|
|
self.start()
|
|
|
|
""" Address Label """
|
|
self.add = tk.StringVar()
|
|
self.DNS = tk.StringVar()
|
|
self.enp = tk.StringVar()
|
|
self.label_empty()
|
|
self.show_data()
|
|
|
|
""" Button Import """
|
|
self.btn_i = ttk.Button(
|
|
self.lb_frame_btn_lbox,
|
|
image=self.imp_pic,
|
|
command=self.import_sl,
|
|
padding=0,
|
|
)
|
|
self.btn_i.grid(column=0, row=1, padx=15, pady=8)
|
|
|
|
def imp_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("Click to import a Wireguard Tunnel")
|
|
)
|
|
|
|
def imp_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.btn_i.bind("<Enter>", imp_enter)
|
|
self.btn_i.bind("<Leave>", imp_leave)
|
|
|
|
def delete():
|
|
|
|
try:
|
|
self.select_tunnel = self.l_box.curselection()
|
|
select_tl = self.l_box.get(self.select_tunnel[0])
|
|
with open("/tmp/tlecdcwg/" + select_tl + ".conf", "r+") as file2:
|
|
key = Tunnel.con_to_dict(file2)
|
|
pre_key = key[3]
|
|
check_call(["nmcli", "connection", "delete", select_tl])
|
|
self.l_box.delete(self.select_tunnel[0])
|
|
with open(wg_set, "r") as set_file6:
|
|
lines6 = set_file6.readlines()
|
|
if (
|
|
select_tl == lines6[7].strip()
|
|
and "off\n" not in lines6[7].strip()
|
|
):
|
|
lines6[7] = "off\n"
|
|
with open(wg_set, "w") as set_file7:
|
|
set_file7.writelines(lines6)
|
|
self.selected_option.set(0)
|
|
self.autoconnect_var.set(_("no Autoconnect"))
|
|
is_encrypt = Path.home() / ".config/wire_py" / str(select_tl + ".dat")
|
|
if is_encrypt.is_file():
|
|
Path.unlink(
|
|
str(Path.home()) + "/.config/wire_py/" + str(select_tl + ".dat")
|
|
)
|
|
Path.unlink(Path("/tmp/tlecdcwg") / str(select_tl + ".conf"))
|
|
with open(str(Path.home()) + "/.config/wire_py/keys", "r") as readfile:
|
|
with open(
|
|
str(Path.home()) + "/.config/wire_py/keys2", "w"
|
|
) as writefile:
|
|
for line in readfile:
|
|
if pre_key not in line.strip("\n"):
|
|
writefile.write(line)
|
|
file_one = Path(str(Path.home()) + "/.config/wire_py/keys2")
|
|
file_two = file_one.with_name("keys")
|
|
file_one.replace(file_two)
|
|
self.wg_autostart.configure(state="disabled")
|
|
|
|
""" for disable checkbox when Listbox empty """
|
|
|
|
def empty_list_start_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("No tunnels to start in the list")
|
|
)
|
|
|
|
def empty_list_start_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
if self.l_box.size() == 0:
|
|
self.wg_autostart.configure(state="disabled")
|
|
self.lb_rename.configure(state="disabled")
|
|
self.l_box.bind("<Enter>", list_empty_enter)
|
|
self.l_box.bind("<Leave>", list_empty_leave)
|
|
self.wg_autostart.bind("<Enter>", chk_enter)
|
|
self.wg_autostart.bind("<Leave>", chk_leave)
|
|
self.btn_tr.bind("<Enter>", empty_list_enter)
|
|
self.btn_tr.bind("<Leave>", empty_list_leave)
|
|
self.btn_exp.bind("<Enter>", empty_list_enter)
|
|
self.btn_exp.bind("<Leave>", empty_list_leave)
|
|
self.btn_stst.bind("<Enter>", empty_list_start_enter)
|
|
self.btn_stst.bind("<Leave>", empty_list_start_leave)
|
|
self.lb_rename.bind("<Enter>", rename_no_active_enter)
|
|
self.lb_rename.bind("<Leave>", rename_no_active_leave)
|
|
self.lb_rename.insert(0, _("Max. 12 characters!"))
|
|
|
|
if self.a != "" and self.a == select_tl:
|
|
self.StrVar.set(value="")
|
|
self.start()
|
|
self.l_box.update()
|
|
|
|
""" Address Label """
|
|
self.add.set("")
|
|
self.DNS.set("")
|
|
self.enp.set("")
|
|
return select_tl
|
|
|
|
except IndexError:
|
|
|
|
if self.l_box.size() != 0:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Select tunnel")
|
|
msg_t = _("Please select a tunnel from the list")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
else:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Select tunnel")
|
|
msg_t = _("Please first import tunnel")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
""" Button Trash """
|
|
self.btn_tr = ttk.Button(
|
|
self.lb_frame_btn_lbox,
|
|
image=self.tr_pic,
|
|
command=delete,
|
|
padding=0,
|
|
style="CButton.TButton",
|
|
)
|
|
self.btn_tr.grid(column=0, row=2, padx=15, pady=8)
|
|
|
|
def empty_list_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("No tunnels to delete in the list")
|
|
)
|
|
|
|
def empty_list_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def del_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("Click to delete a Wireguard Tunnel\nSelect from the list!"),
|
|
)
|
|
|
|
def del_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
if self.l_box.size() == 0:
|
|
self.btn_tr.bind("<Enter>", empty_list_enter)
|
|
self.btn_tr.bind("<Leave>", empty_list_leave)
|
|
else:
|
|
self.btn_tr.bind("<Enter>", del_enter)
|
|
self.btn_tr.bind("<Leave>", del_leave)
|
|
|
|
""" Button Export """
|
|
self.btn_exp = ttk.Button(
|
|
self.lb_frame_btn_lbox, image=self.exp_pic, command=Tunnel.export, padding=0
|
|
)
|
|
self.btn_exp.grid(column=0, row=3, padx=15, pady=8)
|
|
|
|
def empty_list_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("No Tunnels in List for Export")
|
|
)
|
|
|
|
def empty_list_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def exp_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_(" Click to export all\nWireguard Tunnel to Zipfile"),
|
|
)
|
|
|
|
def exp_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
if self.l_box.size() == 0:
|
|
self.btn_exp.bind("<Enter>", empty_list_enter)
|
|
self.btn_exp.bind("<Leave>", empty_list_leave)
|
|
else:
|
|
self.btn_exp.bind("<Enter>", exp_enter)
|
|
self.btn_exp.bind("<Leave>", exp_leave)
|
|
|
|
""" Label Entry """
|
|
self.lb_rename = ttk.Entry(self.lb_frame4, width=20)
|
|
self.lb_rename.grid(column=2, row=0, padx=8, pady=10, sticky="ne")
|
|
self.lb_rename.insert(0, _("Max. 12 characters!"))
|
|
self.lb_rename.config(state="disable")
|
|
|
|
def rename_no_active_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def rename_no_active_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("To rename a tunnel, at least one must be in the list"),
|
|
)
|
|
|
|
def rename_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("To rename a tunnel, you need to\nselect a tunnel from the list"),
|
|
)
|
|
|
|
def rename_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
if self.l_box.size() != 0:
|
|
self.lb_rename.bind("<Enter>", rename_enter)
|
|
self.lb_rename.bind("<Leave>", rename_leave)
|
|
else:
|
|
self.lb_rename.bind("<Enter>", rename_no_active_enter)
|
|
self.lb_rename.bind("<Leave>", rename_no_active_leave)
|
|
|
|
def tl_rename():
|
|
special_characters = ["\\", "/", "{", "}", " "]
|
|
|
|
if len(self.lb_rename.get()) > 12:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Renaming not possible")
|
|
msg_t = _("The new name may contain only 12 characters")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
elif len(self.lb_rename.get()) == 0:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Renaming not possible")
|
|
msg_t = _("At least one character must be entered")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
elif any(ch in special_characters for ch in self.lb_rename.get()):
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Renaming not possible")
|
|
msg_t = _(
|
|
"No valid sign. These must not be used.\nBlank, Slash, Backslash and { }\n"
|
|
)
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
else:
|
|
|
|
try:
|
|
self.select_tunnel = self.l_box.curselection()
|
|
select_tl = self.l_box.get(self.select_tunnel[0])
|
|
|
|
""" nmcli connection modify old connection.id iphone """
|
|
check_call(
|
|
[
|
|
"nmcli",
|
|
"connection",
|
|
"modify",
|
|
select_tl,
|
|
"connection.id",
|
|
self.lb_rename.get(),
|
|
]
|
|
)
|
|
source = Path("/tmp/tlecdcwg") / str(select_tl + ".conf")
|
|
destination = source.with_name(str(self.lb_rename.get() + ".conf"))
|
|
source.replace(destination)
|
|
Path.unlink(
|
|
str(Path.home()) + "/.config/wire_py/" + str(select_tl + ".dat")
|
|
)
|
|
self.l_box.delete(self.select_tunnel[0])
|
|
self.l_box.insert("end", self.lb_rename.get())
|
|
self.l_box.update()
|
|
new_a_connect = self.lb_rename.get()
|
|
self.lb_rename.delete(0, tk.END)
|
|
if self.a != "" and self.a == select_tl:
|
|
self.a = Tunnel.active()
|
|
self.StrVar.set(value=self.a)
|
|
with open(wg_set, "r") as set_file5:
|
|
lines5 = set_file5.readlines()
|
|
if (
|
|
select_tl == lines5[7].strip()
|
|
and "off\n" not in lines5[7].strip()
|
|
):
|
|
lines5[7] = new_a_connect
|
|
with open(wg_set, "w") as theme_set5:
|
|
theme_set5.writelines(lines5)
|
|
self.autoconnect_var.set(value=new_a_connect)
|
|
|
|
Create.encrypt()
|
|
|
|
return select_tl
|
|
|
|
except IndexError:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Renaming not possible")
|
|
msg_t = _("Please select a tunnel from the list")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
""" Button Rename """
|
|
self.btn_rename = ttk.Button(
|
|
self.lb_frame4,
|
|
text=_("Rename"),
|
|
state="disable",
|
|
command=tl_rename,
|
|
padding=4,
|
|
style="RnButton.TButton",
|
|
)
|
|
self.btn_rename.grid(column=3, row=0, padx=5, pady=10, sticky="ne")
|
|
|
|
""" Check Buttons """
|
|
self.selected_option = tk.IntVar()
|
|
self.autoconnect_var = tk.StringVar()
|
|
self.autoconnect_var.set(self.auto_con)
|
|
""" Frame for Labels, Entry and Button"""
|
|
self.autoconnect = ttk.Label(
|
|
self.lb_frame3, textvariable=self.autoconnect_var, width=15
|
|
)
|
|
self.autoconnect.config(font=("Ubuntu", 11))
|
|
self.autoconnect.grid(column=1, row=0, sticky="e", pady=19)
|
|
self.wg_autostart = ttk.Checkbutton(
|
|
self.lb_frame3,
|
|
text=_("Autoconnect on:"),
|
|
variable=self.selected_option,
|
|
command=self.box_set,
|
|
)
|
|
self.wg_autostart.grid(column=0, row=0, pady=15, padx=15, sticky="nw")
|
|
|
|
def chk_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_(
|
|
"You must have at least one\n"
|
|
"tunnel in the list,to use the autostart"
|
|
),
|
|
)
|
|
|
|
def chk_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
if self.l_box.size() >= 1 and len(self.l_box.curselection()) >= 1:
|
|
|
|
def chk_a_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("To use the autostart, enable this Checkbox"),
|
|
)
|
|
|
|
def chk_a_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.wg_autostart.bind("<Enter>", chk_a_enter)
|
|
self.wg_autostart.bind("<Leave>", chk_a_leave)
|
|
|
|
if self.l_box.size() == 0:
|
|
self.wg_autostart.bind("<Enter>", chk_enter)
|
|
self.wg_autostart.bind("<Leave>", chk_leave)
|
|
else:
|
|
|
|
def chk_a_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("To use the autostart, a tunnel must be selected from the list"),
|
|
)
|
|
|
|
def chk_a_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.wg_autostart.bind("<Enter>", chk_a_enter)
|
|
self.wg_autostart.bind("<Leave>", chk_a_leave)
|
|
|
|
self.on_off()
|
|
|
|
def import_sl(self):
|
|
"""
|
|
Import Methode for Wireguard config Files.
|
|
Before importing, it is checked whether PrivateKey and PublicKey are in the file.
|
|
If True then it is checked whether the PreSharedKey is already in the key file
|
|
to avoid an import error so that no double wgconf are imported.
|
|
Thus, tunnels can be renamed without the problems arise. If False then the key is written into the file.
|
|
Furthermore, it is checked whether the name is longer than 12 characters.
|
|
If True then the name is automatically shortened to 12 characters and then imported.
|
|
If in each case false comes out, a corresponding window comes to inform the user that something is wrong.
|
|
"""
|
|
|
|
Create.dir_and_files()
|
|
|
|
try:
|
|
filepath = filedialog.askopenfilename(
|
|
initialdir=str(Path.home()),
|
|
title=_("Select Wireguard config File"),
|
|
filetypes=[(_("WG config files"), "*.conf")],
|
|
)
|
|
|
|
with open(filepath, "r") as file:
|
|
read = file.read()
|
|
path_split = filepath.split("/")
|
|
path_split1 = path_split[-1]
|
|
self.a = Tunnel.active()
|
|
|
|
if (
|
|
"PrivateKey = " in read
|
|
and "PublicKey = " in read
|
|
and "Endpoint =" in read
|
|
):
|
|
with open(filepath, "r") as file:
|
|
key = Tunnel.con_to_dict(file)
|
|
pre_key = key[3]
|
|
if len(pre_key) != 0:
|
|
with open(
|
|
str(Path.home()) + "/.config/wire_py/keys", "r"
|
|
) as readfile:
|
|
p_key = readfile.readlines()
|
|
if pre_key in p_key or pre_key + "\n" in p_key:
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/error.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Import Error")
|
|
msg_t = _(
|
|
"Tunnel already available!\nPlease use another file for import"
|
|
)
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
else:
|
|
|
|
with open(
|
|
str(Path.home()) + "/.config/wire_py/keys", "a"
|
|
) as keyfile:
|
|
keyfile.write(pre_key + "\r")
|
|
if len(path_split1) > 17:
|
|
p1 = shutil.copy(filepath, "/tmp/tlecdcwg/")
|
|
path_split = path_split1[
|
|
len(path_split1) - 17 :
|
|
]
|
|
os.rename(
|
|
p1, "/tmp/tlecdcwg/" + str(path_split)
|
|
)
|
|
new_conf = "/tmp/tlecdcwg/" + path_split
|
|
if self.a != "":
|
|
check_call(
|
|
[
|
|
"nmcli",
|
|
"connection",
|
|
"down",
|
|
Tunnel.active(),
|
|
]
|
|
)
|
|
self.label_empty()
|
|
|
|
subprocess.check_output(
|
|
[
|
|
"nmcli",
|
|
"connection",
|
|
"import",
|
|
"type",
|
|
"wireguard",
|
|
"file",
|
|
new_conf,
|
|
],
|
|
text=True,
|
|
)
|
|
|
|
Create.encrypt()
|
|
|
|
else:
|
|
shutil.copy(filepath, "/tmp/tlecdcwg/")
|
|
if self.a != "":
|
|
check_call(
|
|
[
|
|
"nmcli",
|
|
"connection",
|
|
"down",
|
|
Tunnel.active(),
|
|
]
|
|
)
|
|
self.label_empty()
|
|
|
|
subprocess.check_output(
|
|
[
|
|
"nmcli",
|
|
"connection",
|
|
"import",
|
|
"type",
|
|
"wireguard",
|
|
"file",
|
|
filepath,
|
|
],
|
|
text=True,
|
|
)
|
|
|
|
Create.encrypt()
|
|
|
|
self.StrVar.set("")
|
|
self.a = Tunnel.active()
|
|
self.l_box.insert(0, self.a)
|
|
self.wg_autostart.configure(state="normal")
|
|
self.l_box.selection_clear(0, tk.END)
|
|
self.l_box.update()
|
|
self.l_box.selection_set(0)
|
|
|
|
def chk_a_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_(
|
|
"To use the autostart, enable this "
|
|
"Checkbox"
|
|
),
|
|
)
|
|
|
|
def chk_a_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def list_info_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("List of available tunnels"),
|
|
)
|
|
|
|
def list_info_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def del_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_(
|
|
"Click to delete a Wireguard "
|
|
"Tunnel\nSelect from the list!"
|
|
),
|
|
)
|
|
|
|
def del_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def exp_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_(
|
|
" Click to export "
|
|
"all\nWireguard Tunnel to Zipfile"
|
|
),
|
|
)
|
|
|
|
def exp_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def rename_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_(
|
|
"To rename a tunnel, you need to\n"
|
|
"select a tunnel from the list"
|
|
),
|
|
)
|
|
|
|
def rename_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.wg_autostart.bind("<Enter>", chk_a_enter)
|
|
self.wg_autostart.bind("<Leave>", chk_a_leave)
|
|
self.l_box.bind("<Enter>", list_info_enter)
|
|
self.l_box.bind("<Leave>", list_info_leave)
|
|
self.btn_tr.bind("<Enter>", del_enter)
|
|
self.btn_tr.bind("<Leave>", del_leave)
|
|
self.btn_exp.bind("<Enter>", exp_enter)
|
|
self.btn_exp.bind("<Leave>", exp_leave)
|
|
self.lb_rename.bind("<Enter>", rename_enter)
|
|
self.lb_rename.bind("<Leave>", rename_leave)
|
|
self.lb_rename.insert(0, "Max. 12 characters!")
|
|
self.StrVar = tk.StringVar()
|
|
self.StrVar.set(self.a)
|
|
self.color_label()
|
|
self.stop()
|
|
wg_read = "/tmp/tlecdcwg/" + str(self.a + ".conf")
|
|
with open(wg_read, "r") as file_for_key:
|
|
data = Tunnel.con_to_dict(file_for_key)
|
|
|
|
""" Address Label """
|
|
self.init_and_report(data)
|
|
self.show_data()
|
|
check_call(
|
|
[
|
|
"nmcli",
|
|
"con",
|
|
"mod",
|
|
self.a,
|
|
"connection.autoconnect",
|
|
"no",
|
|
]
|
|
)
|
|
Path.chmod(wg_read, 0o600)
|
|
|
|
if "PrivateKey = " and "Endpoint = " not in read:
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/error.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Import Error")
|
|
msg_t = _(
|
|
"Oh... no valid Wireguard File!\nPlease select a valid Wireguard File"
|
|
)
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
except EOFError:
|
|
pass
|
|
except TypeError:
|
|
pass
|
|
except FileNotFoundError:
|
|
pass
|
|
except subprocess.CalledProcessError:
|
|
|
|
print("Tunnel exist!")
|
|
|
|
def box_set(self):
|
|
"""
|
|
This Method will display the autostart label which
|
|
Tunnel is automatically started regardless of the active tunnel.
|
|
The selected tunnel is written into a file to read it after the start of the system.
|
|
"""
|
|
try:
|
|
select_tunnel = self.l_box.curselection()
|
|
select_tl = self.l_box.get(select_tunnel[0])
|
|
|
|
if self.selected_option.get() == 0:
|
|
with open(wg_set, "r") as set_file3:
|
|
lines3 = set_file3.readlines()
|
|
lines3[7] = "off\n"
|
|
with open(wg_set, "w") as set_file3:
|
|
set_file3.writelines(lines3)
|
|
|
|
tl = Tunnel.list()
|
|
|
|
if len(tl) == 0:
|
|
self.wg_autostart.configure(state="disabled")
|
|
|
|
if self.selected_option.get() >= 1:
|
|
with open(wg_set, "r") as set_file3:
|
|
lines3 = set_file3.readlines()
|
|
lines3[7] = select_tl
|
|
with open(wg_set, "w") as set_file3:
|
|
set_file3.writelines(lines3)
|
|
|
|
except IndexError:
|
|
self.selected_option.set(1)
|
|
|
|
self.on_off()
|
|
|
|
def on_off(self):
|
|
"""
|
|
Here it is checked whether the path to the file is there if not it is created.
|
|
Set (on), the selected tunnel is displayed in the label.
|
|
At (off) the label is first emptied then filled with No Autoconnect
|
|
"""
|
|
with open(wg_set, "r") as set_file4:
|
|
lines4 = set_file4.readlines()
|
|
|
|
if lines4[7] != "off\n":
|
|
print(lines4[7])
|
|
self.selected_option.set(1)
|
|
self.autoconnect_var.set("")
|
|
self.auto_con = lines4[7]
|
|
|
|
else:
|
|
self.selected_option.set(0)
|
|
self.auto_con = _("no Autoconnect")
|
|
|
|
self.autoconnect_var.set("")
|
|
self.autoconnect_var = tk.StringVar()
|
|
self.autoconnect_var.set(self.auto_con)
|
|
|
|
self.autoconnect = ttk.Label(
|
|
self.lb_frame3,
|
|
textvariable=self.autoconnect_var,
|
|
foreground="#0071ff",
|
|
width=15,
|
|
)
|
|
self.autoconnect.config(font=("Ubuntu", 11))
|
|
self.autoconnect.grid(column=1, row=0, sticky="e", pady=19)
|
|
|
|
def init_and_report(self, data=None):
|
|
"""
|
|
Displays the value address, DNS and peer in the labels
|
|
or empty it again
|
|
"""
|
|
|
|
""" Address Label """
|
|
self.add = tk.StringVar()
|
|
self.add.set(_("Address: ") + data[0])
|
|
self.DNS = tk.StringVar()
|
|
self.DNS.set(" DNS: " + data[1])
|
|
self.enp = tk.StringVar()
|
|
self.enp.set(_("Endpoint: ") + data[2])
|
|
|
|
def label_empty(self):
|
|
self.add.set("")
|
|
self.DNS.set("")
|
|
self.enp.set("")
|
|
|
|
def show_data(self):
|
|
"""Address Label"""
|
|
self.address = ttk.Label(
|
|
self.lb_frame, textvariable=self.add, foreground="#0071ff"
|
|
)
|
|
self.address.grid(column=0, row=5, sticky="w", padx=10, pady=6)
|
|
self.address.config(font=("Ubuntu", 9))
|
|
|
|
""" DNS Label """
|
|
self.dns = ttk.Label(self.lb_frame, textvariable=self.DNS, foreground="#0071ff")
|
|
self.dns.grid(column=0, row=7, sticky="w", padx=10, pady=6)
|
|
self.dns.config(font=("Ubuntu", 9))
|
|
|
|
""" Endpoint Label """
|
|
self.endpoint = ttk.Label(
|
|
self.lb_frame2, textvariable=self.enp, foreground="#0071ff"
|
|
)
|
|
self.endpoint.grid(column=0, row=8, sticky="w", padx=10, pady=20)
|
|
self.endpoint.config(font=("Ubuntu", 9))
|
|
|
|
def stop(self):
|
|
"""Stop Button"""
|
|
self.btn_stst = ttk.Button(
|
|
self.lb_frame_btn_lbox,
|
|
image=self.wg_vpn_stop,
|
|
command=self.wg_switch,
|
|
padding=0,
|
|
)
|
|
self.btn_stst.grid(column=0, row=0, padx=5, pady=8)
|
|
|
|
def stop_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("Click to stop selected Wireguard Tunnel")
|
|
)
|
|
|
|
def stop_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
self.btn_stst.bind("<Enter>", stop_enter)
|
|
self.btn_stst.bind("<Leave>", stop_leave)
|
|
|
|
def start(self):
|
|
"""Start Button"""
|
|
self.btn_stst = ttk.Button(
|
|
self.lb_frame_btn_lbox,
|
|
image=self.wg_vpn_start,
|
|
command=self.wg_switch,
|
|
padding=0,
|
|
)
|
|
self.btn_stst.grid(column=0, row=0, padx=5, pady=8)
|
|
|
|
def empty_list_start_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root, event.y_root, _("No tunnels to start in the list")
|
|
)
|
|
|
|
def empty_list_start_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
def start_enter(event):
|
|
"""The mouse moves into the entry widget"""
|
|
window.my_tool_tip = MyToolTip(
|
|
event.x_root,
|
|
event.y_root,
|
|
_("Click to start selected Wireguard Tunnel"),
|
|
)
|
|
|
|
def start_leave(_):
|
|
"""The mouse moves into the entry widget"""
|
|
""" Remove Tool-Tip """
|
|
window.my_tool_tip.destroy()
|
|
|
|
tl = Tunnel.list()
|
|
if len(tl) == 0:
|
|
self.btn_stst.bind("<Enter>", empty_list_start_enter)
|
|
self.btn_stst.bind("<Leave>", empty_list_start_leave)
|
|
else:
|
|
self.btn_stst.bind("<Enter>", start_enter)
|
|
self.btn_stst.bind("<Leave>", start_leave)
|
|
|
|
def color_label(self):
|
|
"""View activ Tunnel in color green or yellow"""
|
|
|
|
with open(wg_set, "r") as read_file:
|
|
lines = read_file.readlines()
|
|
if "light\n" in lines:
|
|
self.lb_tunnel = ttk.Label(
|
|
self, textvariable=self.StrVar, foreground="green"
|
|
)
|
|
|
|
else:
|
|
self.lb_tunnel = ttk.Label(
|
|
self, textvariable=self.StrVar, foreground="yellow"
|
|
)
|
|
|
|
self.lb_tunnel.config(font=("Ubuntu", 11, "bold"))
|
|
self.lb_tunnel.grid(column=2, padx=10, row=1)
|
|
|
|
def wg_switch(self):
|
|
|
|
self.a = Tunnel.active()
|
|
try:
|
|
if self.a == "":
|
|
|
|
self.start()
|
|
self.select_tunnel = self.l_box.curselection()
|
|
select_tl = self.l_box.get(self.select_tunnel[0])
|
|
check_call(["nmcli", "connection", "up", select_tl])
|
|
wg_read = "/tmp/tlecdcwg/" + str(select_tl + ".conf")
|
|
with open(wg_read, "r") as file:
|
|
data = Tunnel.con_to_dict(file)
|
|
|
|
""" Address Label """
|
|
self.init_and_report(data)
|
|
self.show_data()
|
|
|
|
""" Button Start/Stop """
|
|
self.stop()
|
|
self.a = Tunnel.active()
|
|
self.StrVar = tk.StringVar()
|
|
self.StrVar.set(self.a)
|
|
self.color_label()
|
|
|
|
elif self.a != "":
|
|
|
|
"""Button Start/Stop"""
|
|
self.stop()
|
|
check_call(["nmcli", "connection", "down", self.a])
|
|
|
|
""" Button Start/Stop """
|
|
self.start()
|
|
self.a = Tunnel.active()
|
|
self.StrVar.set("")
|
|
self.color_label()
|
|
|
|
""" Address Label """
|
|
self.add.set("")
|
|
self.DNS.set("")
|
|
self.enp.set("")
|
|
self.show_data()
|
|
|
|
except IndexError:
|
|
|
|
if self.l_box.size() != 0:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Select tunnel")
|
|
msg_t = _("Please select a tunnel from the list")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
else:
|
|
|
|
"""img_w, img_i, w_title, w_txt hand over"""
|
|
iw = r"/usr/share/icons/lx-icons/64/info.png"
|
|
ii = r"/usr/share/icons/lx-icons/48/wg_msg.png"
|
|
wt = _("Select tunnel")
|
|
msg_t = _("Please first import tunnel")
|
|
msg_window(iw, ii, wt, msg_t)
|
|
|
|
|
|
class MyToolTip(tk.Toplevel):
|
|
TIP_X_OFFSET = 20
|
|
TIP_Y_OFFSET = 20
|
|
if not wg_tips:
|
|
AUTO_CLEAR_TIME = 0
|
|
else:
|
|
AUTO_CLEAR_TIME = 2000 # Millisecond. (1/200 sec.)
|
|
|
|
def __init__(self, x_pos, y_pos, message=None, auto_clear=True):
|
|
self.x_pos = x_pos
|
|
self.y_pos = y_pos
|
|
self.message = message
|
|
self.auto_clear = auto_clear
|
|
|
|
tk.Toplevel.__init__(self)
|
|
self.overrideredirect(True)
|
|
|
|
self.message_label = ttk.Label(
|
|
self, compound="left", text=self.message, padding=6
|
|
)
|
|
self.message_label.pack()
|
|
|
|
self.geometry(
|
|
"+%d+%d" % (self.x_pos + self.TIP_X_OFFSET, self.y_pos + self.TIP_X_OFFSET)
|
|
)
|
|
|
|
if self.auto_clear:
|
|
self.after(self.AUTO_CLEAR_TIME, self.clear_tip)
|
|
|
|
def clear_tip(self):
|
|
"""Remove Tool-Tip"""
|
|
self.destroy()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
window = Wirepy()
|
|
"""
|
|
the hidden files are hidden in Filedialog
|
|
"""
|
|
try:
|
|
window.tk.call("tk_getOpenFile", "-foobarbaz")
|
|
except TclError:
|
|
pass
|
|
|
|
window.tk.call("set", "::tk::dialog::file::showHiddenBtn", "0")
|
|
window.tk.call("set", "::tk::dialog::file::showHiddenVar", "0")
|
|
window.mainloop()
|
|
|
|
shutil.rmtree(dirname)
|
|
Path.unlink("/tmp/.loguser")
|
|
sys.exit(0)
|