-
-
Notifications
You must be signed in to change notification settings - Fork 140
/
main.py
executable file
·3534 lines (3344 loc) · 138 KB
/
main.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
#!/usr/bin/env python3
# This file is part of Xpra.
# Copyright (C) 2011 Serviware (Arthur Huillet, <ahuillet@serviware.com>)
# Copyright (C) 2010-2021 Antoine Martin <antoine@xpra.org>
# Copyright (C) 2008 Nathaniel Smith <njs@pobox.com>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import sys
import os.path
import stat
import socket
import time
import logging
from time import monotonic
from subprocess import Popen, PIPE, TimeoutExpired
import signal
import shlex
import traceback
from xpra import __version__ as XPRA_VERSION
from xpra.platform.dotxpra import DotXpra
from xpra.util import (
csv, envbool, envint, nonl, pver,
noerr, sorted_nicely, typedict,
DEFAULT_PORTS,
)
from xpra.exit_codes import (
EXIT_STR,
EXIT_OK, EXIT_FAILURE, EXIT_UNSUPPORTED, EXIT_CONNECTION_FAILED,
EXIT_NO_DISPLAY,
EXIT_CONNECTION_LOST, EXIT_REMOTE_ERROR,
EXIT_INTERNAL_ERROR, EXIT_FILE_TOO_BIG,
RETRY_EXIT_CODES,
)
from xpra.os_util import (
get_util_logger, getuid, getgid, get_username_for_uid,
bytestostr, use_tty,
set_proc_title,
is_systemd_pid1,
WIN32, OSX, POSIX, SIGNAMES, is_Ubuntu,
)
from xpra.scripts.parsing import (
info, warn, error,
parse_display_name, parse_env,
fixup_defaults, validated_encodings, validate_encryption, do_parse_cmdline, show_sound_codec_help,
supports_shadow, supports_server, supports_proxy, supports_mdns,
MODE_ALIAS,
)
from xpra.scripts.config import (
OPTION_TYPES, TRUE_OPTIONS, FALSE_OPTIONS, OFF_OPTIONS,
NON_COMMAND_LINE_OPTIONS, CLIENT_ONLY_OPTIONS,
START_COMMAND_OPTIONS, BIND_OPTIONS, PROXY_START_OVERRIDABLE_OPTIONS, OPTIONS_ADDED_SINCE_V3, OPTIONS_COMPAT_NAMES,
InitException, InitInfo, InitExit,
fixup_options, dict_to_validated_config, get_xpra_defaults_dirs, get_defaults, read_xpra_conf,
make_defaults_struct, parse_bool, has_sound_support, name_to_field,
)
from xpra.log import is_debug_enabled, Logger, get_debug_args
assert callable(error), "used by modules importing this function from here"
NO_ROOT_WARNING = envbool("XPRA_NO_ROOT_WARNING", False)
CLIPBOARD_CLASS = os.environ.get("XPRA_CLIPBOARD_CLASS")
WAIT_SERVER_TIMEOUT = envint("WAIT_SERVER_TIMEOUT", 90)
CONNECT_TIMEOUT = envint("XPRA_CONNECT_TIMEOUT", 20)
OPENGL_PROBE_TIMEOUT = envint("XPRA_OPENGL_PROBE_TIMEOUT", 5)
SYSTEMD_RUN = envbool("XPRA_SYSTEMD_RUN", True)
VERIFY_X11_SOCKET_TIMEOUT = envint("XPRA_VERIFY_X11_SOCKET_TIMEOUT", 1)
LIST_REPROBE_TIMEOUT = envint("XPRA_LIST_REPROBE_TIMEOUT", 10)
#pylint: disable=import-outside-toplevel
def nox():
DISPLAY = os.environ.get("DISPLAY")
if DISPLAY is not None:
del os.environ["DISPLAY"]
# This is an error on Fedora/RH, so make it an error everywhere so it will
# be noticed:
import warnings
warnings.filterwarnings("error", "could not open display")
return DISPLAY
def werr(*msg):
for x in msg:
noerr(sys.stderr.write, "%s\n" % (x,))
noerr(sys.stderr.flush)
def add_process(*args, **kwargs):
from xpra.child_reaper import getChildReaper
return getChildReaper().add_process(*args, **kwargs)
def main(script_file, cmdline):
ml = envint("XPRA_MEM_USAGE_LOGGER")
if ml>0:
from xpra.util import start_mem_watcher
start_mem_watcher(ml)
if sys.flags.optimize>0: # pragma: no cover
sys.stderr.write("************************************************************\n")
sys.stderr.write("Warning: the python optimize flag is set to %i\n" % sys.flags.optimize)
sys.stderr.write(" xpra is very likely to crash\n")
sys.stderr.write("************************************************************\n")
time.sleep(5)
from xpra.platform import clean as platform_clean, command_error, command_info
if len(cmdline)==1:
cmdline.append("gui")
#turn off gdk scaling to make sure we get the actual window geometry:
os.environ["GDK_SCALE"]="1"
os.environ["GDK_DPI_SCALE"] = "1"
#client side decorations break window geometry,
#disable this "feature" unless explicitly enabled:
if os.environ.get("GTK_CSD") is None:
os.environ["GTK_CSD"] = "0"
if POSIX and not OSX and os.environ.get("XDG_SESSION_TYPE", "x11")=="x11" and not os.environ.get("GDK_BACKEND"):
os.environ["GDK_BACKEND"] = "x11"
if envbool("XPRA_NOMD5", False):
import hashlib
def nomd5(*_args):
raise ValueError("md5 support is disabled")
hashlib.algorithms_available.remove("md5")
hashlib.md5 = nomd5
def debug_exc(msg="run_mode error"):
get_util_logger().debug(msg, exc_info=True)
try:
defaults = make_defaults_struct()
fixup_defaults(defaults)
options, args = do_parse_cmdline(cmdline, defaults)
#set_proc_title is here so we can override the cmdline later
#(don't ask me why this works)
set_proc_title(" ".join(cmdline))
if not args:
raise InitExit(-1, "xpra: need a mode")
mode = args.pop(0)
mode = MODE_ALIAS.get(mode, mode)
def err(*args):
raise InitException(*args)
return run_mode(script_file, cmdline, err, options, args, mode, defaults)
except SystemExit as e:
debug_exc()
raise
except InitExit as e:
debug_exc()
if str(e) and e.args and (e.args[0] or len(e.args)>1):
command_info("%s" % e)
return e.status
except InitInfo as e:
debug_exc()
command_info("%s" % e)
return 0
except InitException as e:
debug_exc()
command_error("xpra initialization error:\n %s" % e)
return 1
except AssertionError as e:
debug_exc()
command_error("xpra initialization error:\n %s" % e)
traceback.print_tb(sys.exc_info()[2])
return 1
except Exception:
debug_exc()
command_error("xpra main error:\n%s" % traceback.format_exc())
return 1
finally:
platform_clean()
def closestd(std):
if std:
try:
std.close()
except OSError: # pragma: no cover
pass
closestd(sys.stdout)
closestd(sys.stderr)
def configure_logging(options, mode):
if mode in (
"attach", "listen", "launcher",
"sessions", "mdns-gui",
"bug-report", "session-info", "docs",
"recover",
"splash", "qrcode",
"opengl-test",
"desktop-greeter",
"show-menu", "show-about", "show-session-info"
"webcam",
"showconfig",
):
s = sys.stdout
else:
s = sys.stderr
to = s
try:
import codecs
#print("locale.getpreferredencoding()=%s" % (locale.getpreferredencoding(),))
#python3 has a buffer attribute,
#which we must use if we want to be able to write bytes:
sbuf = getattr(s, "buffer", s)
to = codecs.getwriter("utf-8")(sbuf, "replace")
except Exception: # pragma: no cover
pass
#a bit naughty here, but it's easier to let xpra.log initialize
#the logging system every time, and just undo things here..
from xpra.log import (
setloghandler, enable_color, enable_format,
LOG_FORMAT, NOPREFIX_FORMAT,
SIGPIPEStreamHandler,
)
setloghandler(SIGPIPEStreamHandler(to))
if mode in (
"start", "start-desktop", "upgrade", "upgrade-seamless", "upgrade-desktop", "recover",
"attach", "listen", "shadow", "proxy",
"_sound_record", "_sound_play",
"stop", "print", "showconfig",
"request-start", "request-start-desktop", "request-shadow",
"_dialog", "_pass",
"pinentry",
):
if "help" in options.speaker_codec or "help" in options.microphone_codec:
server_mode = mode not in ("attach", "listen")
codec_help = show_sound_codec_help(server_mode, options.speaker_codec, options.microphone_codec)
raise InitInfo("\n".join(codec_help))
fmt = LOG_FORMAT
if mode in ("stop", "showconfig"):
fmt = NOPREFIX_FORMAT
if envbool("XPRA_COLOR_LOG", hasattr(to, "fileno") and os.isatty(to.fileno())):
enable_color(to, fmt)
else:
enable_format(fmt)
from xpra.log import add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for
if options.debug:
categories = options.debug.split(",")
for cat in categories:
if not cat:
continue
if cat[0]=="-":
add_disabled_category(cat[1:])
disable_debug_for(cat[1:])
else:
add_debug_category(cat)
enable_debug_for(cat)
#always log debug level, we just use it selectively (see above)
logging.root.setLevel(logging.INFO)
def configure_network(options):
from xpra.net import compression, packet_encoding
compression.init_compressors(*(list(options.compressors)+["none"]))
ecs = compression.get_enabled_compressors()
if not ecs:
#force compression level to zero since we have no compressors available:
options.compression_level = 0
packet_encoding.init_encoders(*list(options.packet_encoders)+["none"])
ees = set(packet_encoding.get_enabled_encoders())
try:
ees.remove("none")
except KeyError:
pass
#verify that at least one real encoder is available:
if not ees:
raise InitException("at least one valid packet encoder must be enabled")
def configure_env(env_str):
if env_str:
env = parse_env(env_str)
if POSIX and getuid()==0:
#running as root!
#sanitize: only allow "safe" environment variables
#as these may have been specified by a non-root user
env = dict((k,v) for k,v in env.items() if k.startswith("XPRA_"))
os.environ.update(env)
def systemd_run_command(mode, systemd_run_args=None, user=True):
cmd = ["systemd-run", "--description" , "xpra-%s" % mode, "--scope"]
if user:
cmd.append("--user")
LOG_SYSTEMD_WRAP = envbool("XPRA_LOG_SYSTEMD_WRAP", True)
if not LOG_SYSTEMD_WRAP:
cmd.append("--quiet")
if systemd_run_args:
cmd += shlex.split(systemd_run_args)
return cmd
def systemd_run_wrap(mode, args, systemd_run_args=None, **kwargs):
cmd = systemd_run_command(mode, systemd_run_args)
cmd += args
cmd.append("--systemd-run=no")
stderr = sys.stderr
LOG_SYSTEMD_WRAP = envbool("XPRA_LOG_SYSTEMD_WRAP", True)
if LOG_SYSTEMD_WRAP:
noerr(stderr.write, "using systemd-run to wrap '%s' server command\n" % mode)
LOG_SYSTEMD_WRAP_COMMAND = envbool("XPRA_LOG_SYSTEMD_WRAP_COMMAND", False)
if LOG_SYSTEMD_WRAP_COMMAND:
noerr(stderr.write, "%s\n" % " ".join(["'%s'" % x for x in cmd]))
try:
p = Popen(cmd, **kwargs)
return p.wait()
except KeyboardInterrupt:
return 128+signal.SIGINT
def isdisplaytype(args, *dtypes) -> bool:
if not args:
return False
d = args[0]
return any((d.startswith("%s/" % dtype) or d.startswith("%s:" % dtype) for dtype in dtypes))
def check_gtk():
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
assert Gtk
r = Gtk.init_check(None)
if not r[0]:
raise InitExit(EXIT_NO_DISPLAY, "failed to initialize Gtk, no display?")
check_display()
def check_display():
from xpra.platform.gui import can_access_display
if not can_access_display(): # pragma: no cover
raise InitExit(EXIT_NO_DISPLAY, "cannot access display")
def use_systemd_run(s):
if not SYSTEMD_RUN or not POSIX:
return False # pragma: no cover
systemd_run = parse_bool("systemd-run", s)
if systemd_run in (True, False):
return systemd_run
#detect if we should use it:
if is_Ubuntu() and (os.environ.get("SSH_TTY") or os.environ.get("SSH_CLIENT")): # pragma: no cover
#would fail
return False
if not is_systemd_pid1():
return False # pragma: no cover
#test it:
cmd = ["systemd-run", "--quiet", "--user", "--scope", "--", "true"]
proc = Popen(cmd, stdout=PIPE, stderr=PIPE, shell=False)
try:
proc.communicate(timeout=2)
r = proc.returncode
except TimeoutExpired: # pragma: no cover
r = None
if r is None:
try:
proc.terminate()
except Exception:
pass
try:
proc.communicate(timeout=1)
except TimeoutExpired: # pragma: no cover
r = None
return r==0
def run_mode(script_file, cmdline, error_cb, options, args, mode, defaults):
#configure default logging handler:
if POSIX and getuid()==0 and options.uid==0 and mode not in ("proxy", "autostart", "showconfig") and not NO_ROOT_WARNING:
warn("\nWarning: running as root")
display_is_remote = isdisplaytype(args, "ssh", "tcp", "ssl", "vsock")
if mode in (
"start", "start-desktop",
"upgrade", "upgrade-seamless", "upgrade-desktop",
"shadow",
) and not display_is_remote:
if use_systemd_run(options.systemd_run):
#make sure we run via the same interpreter,
#inject it into the command line if we have to:
argv = list(cmdline)
if argv[0].find("python")<0:
argv.insert(0, "python%i.%i" % (sys.version_info.major, sys.version_info.minor))
return systemd_run_wrap(mode, argv, options.systemd_run_args)
configure_env(options.env)
configure_logging(options, mode)
configure_network(options)
if mode not in ("showconfig", "splash") and POSIX and not OSX and os.environ.get("XDG_RUNTIME_DIR") is None and getuid()>0:
xrd = "/run/user/%i" % getuid()
if os.path.exists(xrd):
warn("Warning: using '%s' as XDG_RUNTIME_DIR" % xrd)
os.environ["XDG_RUNTIME_DIR"] = xrd
else:
warn("Warning: XDG_RUNTIME_DIR is not defined")
warn(" and '%s' does not exist" % xrd)
if os.path.exists("/tmp") and os.path.isdir("/tmp"):
xrd = "/tmp"
warn(" using '%s'" % xrd)
os.environ["XDG_RUNTIME_DIR"] = xrd
if not mode.startswith("_sound_"):
#only the sound subcommands should ever actually import GStreamer:
if "gst" in sys.modules or "gi.repository.Gst" in sys.modules:
raise Exception("cannot prevent the import of the GStreamer bindings, already loaded")
sys.modules["gst"] = None
sys.modules["gi.repository.Gst"]= None
#sound commands don't want to set the name
#(they do it later to prevent glib import conflicts)
#"attach" does it when it received the session name from the server
if mode not in (
"attach", "listen",
"start", "start-desktop",
"upgrade", "upgrade-seamless", "upgrade-desktop",
"proxy", "shadow",
):
from xpra.platform import set_name
set_name("Xpra", "Xpra %s" % mode.strip("_"))
if mode in (
"start", "start-desktop",
"shadow", "attach", "listen",
"upgrade", "upgrade-seamless", "upgrade-desktop",
"recover",
"request-start", "request-start-desktop", "request-shadow",
):
options.encodings = validated_encodings(options.encodings)
try:
return do_run_mode(script_file, cmdline, error_cb, options, args, mode, defaults)
except KeyboardInterrupt as e:
info("\ncaught %s, exiting" % repr(e))
return 128+signal.SIGINT
def do_run_mode(script_file, cmdline, error_cb, options, args, mode, defaults):
display_is_remote = isdisplaytype(args, "ssh", "tcp", "ssl", "vsock")
if mode in ("start", "start-desktop", "shadow") and display_is_remote:
#ie: "xpra start ssh://USER@HOST:SSHPORT/DISPLAY --start-child=xterm"
return run_remote_server(script_file, cmdline, error_cb, options, args, mode, defaults)
if mode in ("start", "start-desktop") and args and parse_bool("attach", options.attach) is True:
assert not display_is_remote
#maybe the server is already running
#and we don't need to bother trying to start it:
try:
display = pick_display(error_cb, options, args)
except Exception:
pass
else:
dotxpra = DotXpra(options.socket_dir, options.socket_dirs)
display_name = display.get("display_name")
if display_name:
state = dotxpra.get_display_state(display_name)
if state==DotXpra.LIVE:
noerr(sys.stdout.write, "existing live display found, attaching")
return do_run_mode(script_file, cmdline, error_cb, options, args, "attach", defaults)
if mode in (
"start", "start-desktop",
"upgrade", "upgrade-seamless", "upgrade-desktop",
"shadow", "proxy",
):
return run_server(script_file, cmdline, error_cb, options, args, mode, defaults)
elif mode in (
"attach", "listen", "detach",
"screenshot", "version", "info", "id",
"control", "_monitor", "shell", "print",
"qrcode",
"show-menu", "show-about", "show-session-info",
"connect-test", "request-start", "request-start-desktop", "request-shadow",
):
return run_client(script_file, cmdline, error_cb, options, args, mode)
elif mode in ("stop", "exit"):
no_gtk()
return run_stopexit(mode, error_cb, options, args)
elif mode == "top":
no_gtk()
return run_top(error_cb, options, args)
elif mode == "list":
no_gtk()
return run_list(error_cb, options, args)
elif mode == "list-windows":
no_gtk()
return run_list_windows(error_cb, options, args)
elif mode == "list-mdns" and supports_mdns:
no_gtk()
return run_list_mdns(error_cb, args)
elif mode == "mdns-gui" and supports_mdns:
check_gtk()
return run_mdns_gui(error_cb, options)
elif mode == "list-sessions":
no_gtk()
return run_list_sessions(args, options)
elif mode == "sessions":
no_gtk()
return run_sessions_gui(error_cb, options)
elif mode == "displays":
no_gtk()
return run_displays(args)
elif mode == "clean-displays":
no_gtk()
return run_clean_displays(args)
elif mode == "clean-sockets":
no_gtk()
return run_clean_sockets(options, args)
elif mode == "clean":
no_gtk()
return run_clean(options, args)
elif mode=="recover":
return run_recover(script_file, cmdline, error_cb, options, args, defaults)
elif mode == "wminfo":
no_gtk()
return run_wminfo(args)
elif mode == "wmname":
no_gtk()
return run_wmname(args)
elif mode == "desktop-greeter":
check_gtk()
return run_desktop_greeter(args)
elif mode == "launcher":
check_gtk()
from xpra.client.gtk_base.client_launcher import main as launcher_main
return launcher_main(["xpra"]+args)
elif mode == "gui":
check_gtk()
from xpra.gtk_common import gui
return gui.main(cmdline)
elif mode == "start-gui":
check_gtk()
from xpra.gtk_common import start_gui
return start_gui.main(options)
elif mode == "bug-report":
check_gtk()
from xpra.scripts import bug_report
bug_report.main(["xpra"]+args)
elif mode == "session-info":
return run_session_info(error_cb, options, args)
elif mode == "docs":
return run_docs()
elif mode == "html5":
return run_html5()
elif (
mode=="_proxy" or
(mode in ("_proxy_start", "_proxy_start_desktop") and supports_server) or
(mode=="_proxy_shadow_start" and supports_shadow)
):
nox()
return run_proxy(error_cb, options, script_file, args, mode, defaults)
elif mode in ("_sound_record", "_sound_play", "_sound_query"):
if not has_sound_support():
error_cb("no sound support!")
from xpra.sound.wrapper import run_sound
return run_sound(mode, error_cb, options, args)
elif mode=="pinentry":
check_gtk()
from xpra.scripts.pinentry_wrapper import run_pinentry
return run_pinentry(args)
elif mode=="_dialog":
check_gtk()
return run_dialog(args)
elif mode=="_pass":
check_gtk()
return run_pass(args)
elif mode=="send-file":
check_gtk()
return run_send_file(args)
elif mode=="splash":
check_gtk()
return run_splash(args)
elif mode=="opengl":
check_gtk()
return run_glcheck(options)
elif mode=="opengl-probe":
check_gtk()
return run_glprobe(options)
elif mode=="opengl-test":
check_gtk()
return run_glprobe(options, True)
elif mode=="autostart":
return run_autostart(script_file, args)
elif mode=="encoding":
from xpra.codecs import loader
return loader.main(args)
elif mode=="applications-menu" or mode=="sessions-menu":
from xpra.server.menu_provider import MenuProvider
if mode=="applications-menu":
data = MenuProvider().get_menu_data(remove_icons=True)
else:
data = MenuProvider().get_desktop_sessions(remove_icons=True)
if not data:
print("no menu data available")
else:
from xpra.util import print_nested_dict
print_nested_dict(data)
elif mode=="video":
from xpra.codecs import video_helper
return video_helper.main()
elif mode=="nvinfo":
from xpra.codecs import nv_util
return nv_util.main()
elif mode=="webcam":
check_gtk()
from xpra.scripts import show_webcam
return show_webcam.main()
elif mode=="keyboard":
from xpra.platform import keyboard
return keyboard.main()
elif mode=="gtk-info":
check_gtk()
from xpra.scripts import gtk_info
return gtk_info.main()
elif mode=="gui-info":
check_gtk()
from xpra.platform import gui
return gui.main()
elif mode=="network-info":
from xpra.net import net_util
return net_util.main()
elif mode=="compression":
from xpra.net import compression
return compression.main()
elif mode=="packet-encoding":
from xpra.net import packet_encoding
return packet_encoding.main()
elif mode=="path-info":
from xpra.platform import paths
return paths.main()
elif mode=="printing-info":
from xpra.platform import printing
return printing.main(args)
elif mode=="version-info":
from xpra.scripts import version
return version.main()
elif mode=="toolbox":
check_gtk()
from xpra.client.gtk_base import toolbox
return toolbox.main()
elif mode == "initenv":
if not POSIX:
raise InitExit(EXIT_UNSUPPORTED, "initenv is not supported on this OS")
from xpra.server.server_util import xpra_runner_shell_script, write_runner_shell_scripts
script = xpra_runner_shell_script(script_file, os.getcwd())
write_runner_shell_scripts(script, False)
return 0
elif mode=="auth":
return run_auth(options, args)
elif mode == "showconfig":
return run_showconfig(options, args)
elif mode == "showsetting":
return run_showsetting(args)
else:
from xpra.scripts.parsing import get_usage
if mode!="help":
print("Invalid subcommand '%s'" % (mode,))
print("Usage:")
from xpra.platform.features import LOCAL_SERVERS_SUPPORTED
if not LOCAL_SERVERS_SUPPORTED:
print("(this xpra installation does not support starting local servers)")
cmd = os.path.basename(script_file)
for x in get_usage():
print("\t%s %s" % (cmd, x))
print()
print("see 'man xpra' or 'xpra --help' for more details")
return 1
def find_session_by_name(opts, session_name):
from xpra.platform.paths import get_nodock_command
dotxpra = DotXpra(opts.socket_dir, opts.socket_dirs)
socket_paths = dotxpra.socket_paths(check_uid=getuid(), matching_state=DotXpra.LIVE)
if not socket_paths:
return None
id_sessions = {}
for socket_path in socket_paths:
cmd = get_nodock_command()+["id", "socket://%s" % socket_path]
proc = Popen(cmd, stdout=PIPE, stderr=PIPE)
id_sessions[socket_path] = proc
now = monotonic()
while any(proc.poll() is None for proc in id_sessions.values()) and monotonic()-now<10:
time.sleep(0.5)
session_uuid_to_path = {}
for socket_path, proc in id_sessions.items():
if proc.poll()==0:
out, err = proc.communicate()
d = {}
for line in bytestostr(out or err).splitlines():
try:
k,v = line.split("=", 1)
d[k] = v
except ValueError:
continue
name = d.get("session-name")
uuid = d.get("uuid")
if name==session_name and uuid:
session_uuid_to_path[uuid] = socket_path
if not session_uuid_to_path:
return None
if len(session_uuid_to_path)>1:
raise InitException("more than one session found matching '%s'" % session_name)
return "socket://%s" % tuple(session_uuid_to_path.values())[0]
def display_desc_to_uri(display_desc):
dtype = display_desc.get("type")
if not dtype:
raise InitException("missing display type")
uri = "%s://" % dtype
username = display_desc.get("username")
if username is not None:
uri += username
password = display_desc.get("password")
if password is not None:
uri += ":"+password
if username is not None or password is not None:
uri += "@"
if dtype in ("ssh", "tcp", "ssl", "ws", "wss"):
#TODO: re-add 'proxy_host' arguments here
host = display_desc.get("host")
if not host:
raise InitException("missing host from display parameters")
uri += host
port = display_desc.get("port")
if port and port!=DEFAULT_PORTS.get(dtype):
uri += ":%i" % port
elif dtype=="vsock":
cid, iport = display_desc["vsock"]
uri += "%s:%s" % (cid, iport)
else:
raise NotImplementedError("%s is not implemented yet" % dtype)
uri += "/"
display = display_desc.get("display")
if display:
uri += display.lstrip(":")
return uri
def pick_vnc_display(error_cb, opts, extra_args):
if extra_args and len(extra_args)==1:
try:
display = extra_args[0].lstrip(":")
display_no = int(display)
except (ValueError, TypeError):
pass
else:
return {
"display" : ":%i" % display_no,
"display_name" : display,
"host" : "localhost",
"port" : 5900+display_no,
"local" : True,
"type" : "tcp",
}
error_cb("cannot find vnc displays yet")
def pick_display(error_cb, opts, extra_args):
if len(extra_args)==1 and extra_args[0].startswith("vnc"):
#can't identify vnc displays with xpra sockets
#try the first N standard vnc ports:
#(we could use threads to port scan more quickly)
N = 100
from xpra.net.socket_util import socket_connect
for i in range(N):
if not os.path.exists("%s/X%i" % (X11_SOCKET_DIR, i)):
#no X11 socket, assume no VNC server
continue
port = 5900+i
sock = socket_connect("localhost", port, timeout=0.1)
if sock:
return {
"type" : "vnc",
"local" : True,
"host" : "localhost",
"port" : port,
"display" : ":%i" % i,
"display_name" : ":%i" % i,
}
#if not, then fall through and hope that the xpra server supports vnc:
dotxpra = DotXpra(opts.socket_dir, opts.socket_dirs)
return do_pick_display(dotxpra, error_cb, opts, extra_args)
def do_pick_display(dotxpra, error_cb, opts, extra_args):
if not extra_args:
# Pick a default server
dir_servers = dotxpra.socket_details(matching_state=DotXpra.LIVE)
try:
sockdir, display, sockpath = single_display_match(dir_servers, error_cb)
except:
if getuid()==0 and opts.system_proxy_socket:
display = ":PROXY"
sockdir = os.path.dirname(opts.system_proxy_socket)
sockpath = opts.system_proxy_socket
else:
raise
desc = {
"local" : True,
"display" : display,
"display_name" : display,
}
if WIN32: # pragma: no cover
desc.update({
"type" : "named-pipe",
"named-pipe" : sockpath,
})
else:
desc.update({
"type" : "unix-domain",
"socket_dir" : sockdir,
"socket_path" : sockpath,
})
return desc
if len(extra_args) == 1:
return parse_display_name(error_cb, opts, extra_args[0], find_session_by_name=find_session_by_name)
error_cb("too many arguments (%i): %s" % (len(extra_args), extra_args))
return None
def single_display_match(dir_servers, error_cb, nomatch="cannot find any live servers to connect to"):
#ie: {"/tmp" : [LIVE, "desktop-10", "/tmp/desktop-10"]}
#aggregate all the different locations:
allservers = []
noproxy = []
for sockdir, servers in dir_servers.items():
for state, display, path in servers:
if state==DotXpra.LIVE:
allservers.append((sockdir, display, path))
if not display.startswith(":proxy-"):
noproxy.append((sockdir, display, path))
if not allservers:
error_cb(nomatch)
if len(allservers)>1:
#maybe the same server is available under multiple paths
displays = set(v[1] for v in allservers)
if len(displays)==1:
#they all point to the same display, use the first one:
allservers = allservers[:1]
if len(allservers)>1 and noproxy:
#try to ignore proxy instances:
displays = set(v[1] for v in noproxy)
if len(displays)==1:
#they all point to the same display, use the first one:
allservers = noproxy[:1]
if len(allservers) > 1:
error_cb("there are multiple servers running, please specify")
assert len(allservers)==1
sockdir, name, path = allservers[0]
#ie: ("/tmp", "desktop-10", "/tmp/desktop-10")
return sockdir, name, path
def connect_or_fail(display_desc, opts):
from xpra.net.bytestreams import ConnectionClosedException
try:
return connect_to(display_desc, opts)
except ConnectionClosedException as e:
raise InitExit(EXIT_CONNECTION_FAILED, "%s" % e) from None
except InitException:
raise
except InitExit:
raise
except InitInfo:
raise
except Exception as e:
Logger("network").debug("failed to connect", exc_info=True)
raise InitException("connection failed: %s" % e) from None
def retry_socket_connect(dtype, host, port, timeout=20):
from xpra.net.socket_util import socket_connect
start = monotonic()
retry = 0
while True:
sock = socket_connect(host, port, timeout=timeout)
if sock:
return sock
if monotonic()-start>=timeout:
break
if retry==0:
werr("failed to connect to %s:%s, retrying for %i seconds" % (host, port, timeout))
retry += 1
time.sleep(1)
raise InitExit(EXIT_CONNECTION_FAILED, "failed to connect to %s socket %s:%s" % (dtype, host, port))
def get_host_target_string(display_desc, port_key="port", prefix=""):
dtype = display_desc["type"]
username = display_desc.get(prefix+"username")
host = display_desc[prefix+"host"]
try:
port = int(display_desc.get(prefix+port_key))
if not 0<port<2**16:
port = 0
except (ValueError, TypeError):
port = 0
display = display_desc.get(prefix+"display", "")
return host_target_string(dtype, username, host, port, display)
def host_target_string(dtype, username, host, port, display):
target = "%s://" % dtype
if username:
target += "%s@" % username
target += host
default_port = DEFAULT_PORTS.get(dtype, 0)
if port and port!=default_port:
target += ":%i" % port
if display and display.startswith(":"):
display = display[1:]
target += "/%s" % (display or "")
return target
def connect_to(display_desc, opts=None, debug_cb=None, ssh_fail_cb=None):
from xpra.net.bytestreams import SOCKET_TIMEOUT, VSOCK_TIMEOUT, SocketConnection
display_name = display_desc["display_name"]
dtype = display_desc["type"]
if dtype in ("ssh", "vnc+ssh"):
from xpra.net.ssh import ssh_paramiko_connect_to, ssh_exec_connect_to
if display_desc.get("is_paramiko", False):
conn = ssh_paramiko_connect_to(display_desc)
else:
conn = ssh_exec_connect_to(display_desc, opts, debug_cb, ssh_fail_cb)
if dtype=="vnc+ssh":
conn.socktype = "vnc"
conn.socktype_wrapped = "ssh"
return conn
if dtype == "unix-domain":
if not hasattr(socket, "AF_UNIX"): # pragma: no cover
raise InitExit(EXIT_UNSUPPORTED, "unix domain sockets are not available on this operating system")
def sockpathfail_cb(msg):
raise InitException(msg)
sockpath = get_sockpath(display_desc, sockpathfail_cb)
display_desc["socket_path"] = sockpath
sock = socket.socket(socket.AF_UNIX)
sock.settimeout(SOCKET_TIMEOUT)
try:
sock.connect(sockpath)
except Exception as e:
get_util_logger().debug("failed to connect using %s%s", sock.connect, sockpath, exc_info=True)
noerr(sock.close)
raise InitExit(EXIT_CONNECTION_FAILED, "failed to connect to '%s':\n %s" % (sockpath, e)) from None
sock.settimeout(None)
conn = SocketConnection(sock, sock.getsockname(), sock.getpeername(), display_name, dtype)
conn.timeout = SOCKET_TIMEOUT
target = "socket://"
if display_desc.get("username"):
target += "%s@" % display_desc.get("username")
target += sockpath
conn.target = target
return conn
if dtype == "named-pipe": # pragma: no cover
pipe_name = display_desc["named-pipe"]
if not WIN32:
raise InitException("named pipes are only supported on MS Windows")
import errno
from xpra.platform.win32.dotxpra import PIPE_PATH, PIPE_ROOT
from xpra.platform.win32.namedpipes.connection import NamedPipeConnection, connect_to_namedpipe
if pipe_name.startswith(PIPE_ROOT):
#absolute pipe path already specified
path = pipe_name
else:
path = PIPE_PATH+pipe_name
try:
pipe_handle = connect_to_namedpipe(path)
except Exception as e:
try:
if e.args[0]==errno.ENOENT:
raise InitException("the named pipe '%s' does not exist: %s" % (pipe_name, e)) from None
except AttributeError:
pass
raise InitException("failed to connect to the named pipe '%s':\n %s" % (pipe_name, e)) from None
conn = NamedPipeConnection(pipe_name, pipe_handle, {})
conn.timeout = SOCKET_TIMEOUT
conn.target = "namedpipe://%s/" % pipe_name
return conn
if dtype == "vsock":
cid, iport = display_desc["vsock"]
from xpra.net.vsock import ( #pylint: disable=no-name-in-module
connect_vsocket, #@UnresolvedImport
CID_TYPES, CID_ANY, PORT_ANY, #@UnresolvedImport
)
sock = connect_vsocket(cid=cid, port=iport)
sock.timeout = VSOCK_TIMEOUT
sock.settimeout(None)
conn = SocketConnection(sock, "local", "host", (CID_TYPES.get(cid, cid), iport), dtype)
conn.target = "vsock://%s:%s" % (
"any" if cid==CID_ANY else cid,
"any" if iport==PORT_ANY else iport,
)
return conn
if dtype in ("tcp", "ssl", "ws", "wss", "vnc"):
host = display_desc["host"]
port = display_desc["port"]
sock = retry_socket_connect(dtype, host, port)
sock.settimeout(None)
conn = SocketConnection(sock, sock.getsockname(), sock.getpeername(), display_name, dtype, socket_options=display_desc)
if dtype in ("ssl", "wss"):
strict_host_check = display_desc.get("strict-host-check")
if strict_host_check is False:
opts.ssl_server_verify_mode = "none"
from xpra.net.socket_util import ssl_wrap_socket, get_ssl_attributes, ssl_handshake
if not opts.ssl_server_hostname: