File xosview-1.19.dif of Package xosview

Overview Repositories Revisions Requests Users Attributes Meta

File xosview-1.19.dif of Package xosview (Revision d943fbcaecedc4d5e3477b35a0a9108c)

Currently displaying revision d943fbcaecedc4d5e3477b35a0a9108c , Show latest

--- README.linux
+++ README.linux	2020-04-02 06:19:40.181330816 +0000
@@ -26,7 +26,7 @@ To install xosview:
      to /usr/bin/X11/xosview and will be suid root.  If you do not want to
      run xosview suid root (this will just disable the serial meters) you
      can change the permissions to whatever you like.  The X defaults for
-     xosview (Xdefaults) are copied to /usr/lib/X11/app-defaults/XOsview.
+     xosview (Xdefaults) are copied to /usr/share/X11/app-defaults/XOsview.
 
   To run xosview :
 
--- README.security
+++ README.security	2020-04-02 06:19:40.181330816 +0000
@@ -0,0 +1,35 @@
+
+Xosview, serial meters, and suid bit
+====================================
+
+   The program xosview is able to display the serial interfaces of your
+   system.  Unfortunately this requires root permissions.  Therefore this
+   feature is *disabled* by default in
+
+        /usr/share/X11/app-defaults/XOsview
+
+   and the program /usr/X11R6/bin/xosview does *not* run suid root due to
+   lack of security of xosview. It *is* exploitable at some parts of its code.
+
+   If you want to use the serial meters you have to change `xosview*serial<X>'
+   in /usr/share/X11/app-defaults/XOsview *and* add a line
+
+      /usr/X11R6/bin/xosview.bin   root.root    4755
+
+   to /etc/permissions.local. If you are using PERMISSION_SECURITY="easy local"
+   in /etc/rc.config and you don't want xosview to be suid root you should add
+   the line
+
+      /usr/X11R6/bin/xosview.bin   root.root    0755
+
+   to /etc/permissions.local.  In both cases, after the next run of SuSEconfig
+   the permissions are set according to your choice.
+
+   In normal cases the serial meters are not very useful. Therefore
+   the secure defaults should be used.
+
+
+   Have a lot of fun...
+
+                            Your SuSE Team
+
--- Xdefaults
+++ Xdefaults	2020-04-02 06:19:40.181330816 +0000
@@ -2,129 +2,130 @@
 
 ! General Resources
 
-!xosview*title:
-!xosview*geometry:           +5+5
-!xosview*display:
-xosview*captions:           True
-xosview*labels:             True
-xosview*meterLabelColor:    wheat
-xosview*usedlabels:         True
-xosview*usedLabelColor:     wheat
-xosview*borderwidth:        1
-xosview*font:               7x13bold
-xosview*background:         navy
-xosview*foreground:         wheat
-xosview*enableStipple:	    False ! Change to true to try beta stipple support.
-xosview*samplesPerSec:      10
-xosview*graphNumCols:       135   ! number of samples shown in a graph
+!*title:
+!*geometry:           +5+5
+!*display:
+*captions:           True
+*labels:             True
+*meterLabelColor:    black
+*usedlabels:         True
+*usedLabelColor:     black
+*borderwidth:        1
+*font:               6x10
+*background:         grey77
+*foreground:         black
+*enableStipple:	     False ! Change to true to try beta stipple support.
+*samplesPerSec:      10
+*graphNumCols:       135   ! number of samples shown in a graph
 
 ! Load Meter Resources
 ! We don't need to enable the Decay option, as it is already time-averaged.
 
-xosview*load:               True
-xosview*loadCritColor:      red
-xosview*loadWarnColor:      orange
-xosview*loadProcColor:      seagreen
-xosview*loadIdleColor:      aquamarine
-xosview*loadPriority:       20
-xosview*loadCritThreshold:  auto  ! auto or number
-xosview*loadWarnThreshold:  auto  ! auto or number
-xosview*loadDecay:          False
-xosview*loadGraph:          False
-xosview*loadUsedFormat:     float
-xosview*loadCpuSpeed:       True
+*load:               True
+*loadCritColor:      red
+*loadWarnColor:      orange
+*loadProcColor:      blue
+*loadIdleColor:      green2
+*loadPriority:       20
+*loadCritThreshold:  auto  ! auto or number
+*loadWarnThreshold:  auto  ! auto or number
+*loadDecay:          False
+*loadGraph:          False
+*loadUsedFormat:     float
+*loadCpuSpeed:       True
 
 ! Gfx Meter Resources ( Irix )
 
-xosview*gfx:               True
-xosview*gfxCritColor:      red
-xosview*gfxWarnColor:      orange
-xosview*gfxSwapColor:      seagreen
-xosview*gfxIdleColor:      aquamarine
-xosview*gfxPriority:       1    ! don't change, until you know what you do
-xosview*gfxCritThreshold:  120  ! swapbuffers/s per pipe
-xosview*gfxWarnThreshold:  60   ! swapbuffers/s per pipe
-xosview*gfxDecay:          False
-xosview*gfxGraph:          False
-xosview*gfxUsedFormat:	   autoscale
+*gfx:                True
+*gfxCritColor:       red
+*gfxWarnColor:       orange
+*gfxSwapColor:       blue
+*gfxIdleColor:       green2
+*gfxPriority:        1    ! don't change, until you know what you do
+*gfxCritThreshold:   120  ! swapbuffers/s per pipe
+*gfxWarnThreshold:   60   ! swapbuffers/s per pipe
+*gfxDecay:           False
+*gfxGraph:           False
+*gfxUsedFormat:	     autoscale
 
 ! CPU Meter Resources
 
-xosview*cpu:                True
-xosview*cpuFields:          USR SYS WIO IDLE
-xosview*cpuUserColor:       seagreen
-xosview*cpuNiceColor:       yellow
-xosview*cpuSystemColor:     orange
-xosview*cpuInterruptColor:  lightblue
-xosview*cpuSInterruptColor: orange red
-xosview*cpuWaitColor:       red
-xosview*cpuFreeColor:       aquamarine
-xosview*cpuGuestColor:      blue
-xosview*cpuNiceGuestColor:  gold
-xosview*cpuStolenColor:     purple
-xosview*cpuPriority:        1
-xosview*cpuDecay:           True
-xosview*cpuGraph:           True
-xosview*cpuUsedFormat:	    percent
-xosview*cpuFormat:          auto   ! single, all, auto or both
+*cpu:                True
+*cpuFields:          USR SYS WIO IDLE
+*cpuUserColor:       blue
+*cpuNiceColor:       yellow
+*cpuSystemColor:     red
+*cpuInterruptColor:  SkyBlue3
+*cpuSInterruptColor: OrangeRed
+*cpuWaitColor:       white
+*cpuFreeColor:       green2
+*cpuGuestColor:      DarkBlue
+*cpuNiceGuestColor:  gold
+*cpuStolenColor:     purple
+*cpuPriority:        1
+*cpuDecay:           True
+*cpuGraph:           False
+*cpuUsedFormat:	     percent
+*cpuFormat:          auto   ! single, all, auto or both
 
 ! Memory Meter Resources
 ! Not all of these are used by a specific platform.
 
-xosview*mem:                True
-xosview*memKernelColor:     yellow
-xosview*memUsedColor:       seagreen
-xosview*memSharedColor:     SkyBlue
-xosview*memBufferColor:     red
-xosview*memSlabColor:	    blue
-xosview*memCacheColor:      orange
-xosview*memFreeColor:       aquamarine
-xosview*memTextColor:       blue
-xosview*memOtherColor:      orange
-xosview*memActiveColor:	    blue
-xosview*memInactiveColor:   lightblue
-xosview*memWiredColor:      orange
-xosview*memPriority:        10
-xosview*memDecay:           False
-xosview*memGraph:           False
-xosview*memUsedFormat:	    autoscale
+*mem:                True
+*memKernelColor:     BlueViolet
+*memUsedColor:       blue
+*memSharedColor:     yellow
+*memBufferColor:     DarkOrange
+*memSlabColor:	     DarkBlue
+*memCacheColor:      red
+*memFreeColor:       green2
+*memTextColor:       white
+*memOtherColor:      grey
+*memActiveColor:     gold
+*memInactiveColor:   lightblue
+*memWiredColor:      orange
+*memPriority:        10
+*memDecay:           False
+*memGraph:           False
+*memUsedFormat:	     autoscale
 
 ! Swap Meter Resources
 
-xosview*swap:               True
-xosview*swapUsedColor:      seagreen
-xosview*swapFreeColor:      aquamarine
-xosview*swapPriority:       10
-xosview*swapDecay:          False
-xosview*swapGraph:          False
-xosview*swapUsedFormat:	    autoscale
+*swap:               True
+*swapUsedColor:      blue
+*swapFreeColor:      green2
+*swapPriority:       10
+*swapDecay:          False
+*swapGraph:          False
+*swapUsedFormat:	    autoscale
 
 
 ! Page Meter Resources
 
-xosview*page:               True
-xosview*pageBandwidth:      120
-xosview*pageInColor:        SkyBlue
-xosview*pageOutColor:       SlateBlue1
-xosview*pageIdleColor:      aquamarine
-xosview*pagePriority:       5
-xosview*pageDecay:          False
-xosview*pageGraph:          False
-xosview*pageUsedFormat:     autoscale
+*page:               True
+*pageBandwidth:      120
+*pageInColor:        blue
+*pageOutColor:       red
+*pageIdleColor:      green2
+*pagePriority:       5
+*pageDecay:          False
+*pageGraph:          False
+*pageUsedFormat:     autoscale
 
 
 ! Network Meter Resources
 
-xosview*net:		    True
-xosview*netBandwidth:       10000000  ! for 100Mbit/s
-xosview*netInColor:         SkyBlue
-xosview*netOutColor:        SlateBlue1
-xosview*netBackground:      aquamarine
-xosview*netPriority:        2
-xosview*netDecay:           True
-xosview*netGraph:           True
-xosview*netUsedFormat:	    autoscale
-xosview*netIface:           False
+*net:		     True
+*netBandwidth:       1000000  ! for 100Mbit/s
+!*netBandwidth:      10000000  ! for 100Mbit/s
+*netInColor:         blue
+*netOutColor:        red
+*netBackground:      green2
+*netPriority:        2
+*netDecay:           True
+*netGraph:           False
+*netUsedFormat:	     autoscale
+*netIface:           False
 
 ! Linux-only resources:
 
@@ -134,159 +135,159 @@ xosview*netIface:           False
 ! (autodetection may fail sometimes, if the port is
 ! locked by ppp/slip for example)
 
-!xosview*serial0:            0x3f8
-!xosview*serial1:            0x2f8
-!xosview*serial2:            0x3e8
-!xosview*serial3:            0x2e8
-xosview*serial0:            False
-xosview*serial1:            False
-xosview*serial2:            False
-xosview*serial3:            False
-xosview*serial4:            False
-xosview*serial5:            False
-xosview*serial6:            False
-xosview*serial7:            False
-xosview*serial8:            False
-xosview*serial9:            False
-xosview*serialOnColor:      red
-xosview*serialOffColor:     aquamarine
-xosview*serialPriority:     1
+!*serial0:            0x3f8
+!*serial1:            0x2f8
+!*serial2:            0x3e8
+!*serial3:            0x2e8
+*serial0:            False
+*serial1:            False
+*serial2:            False
+*serial3:            False
+*serial4:            False
+*serial5:            False
+*serial6:            False
+*serial7:            False
+*serial8:            False
+*serial9:            False
+*serialOnColor:      red
+*serialOffColor:     blue
+*serialPriority:     1
 
 ! Interrupt Meter Resources
 
-xosview*interrupts:         False
-xosview*intSeparate:        False
-xosview*intOnColor:         red
-xosview*intOffColor:        aquamarine
-xosview*intPriority:	    1
+*interrupts:         False
+*intSeparate:        False
+*intOnColor:         red
+*intOffColor:        blue
+*intPriority:	     1
 
 ! Interrupt Rate Meter Resources
-xosview*irqrate:	False
-xosview*irqrateUsedColor:	red
-xosview*irqrateIdleColor:	aquamarine
-xosview*irqratePriority:	1
-xosview*irqrateUsedFormat:  autoscale
-xosview*irqrateDecay:	True
-xosview*irqrateGraph:	False
+*irqrate:	True
+*irqrateUsedColor:	red
+*irqrateIdleColor:	blue
+*irqratePriority:	1
+*irqrateUsedFormat:  autoscale
+*irqrateDecay:	True
+*irqrateGraph:	False
 
 ! Battery Meter Resources
 
-xosview*battery:            True
-xosview*batteryLeftColor:   orange
-xosview*batteryUsedColor:   aquamarine
-xosview*batteryPriority:    50
-xosview*batteryUsedFormat:  percent
-xosview*batteryChargeColor: seagreen
-xosview*batteryFullColor:   magenta
-xosview*batteryLowColor:    red
-xosview*batteryCritColor:   red
-xosview*batteryNoneColor:   grey
+*battery:            True
+*batteryLeftColor:   blue
+*batteryUsedColor:   red
+*batteryPriority:    50
+*batteryUsedFormat:  percent
+*batteryChargeColor: green2
+*batteryFullColor:   magenta
+*batteryLowColor:    orange
+*batteryCritColor:   red
+*batteryNoneColor:   grey
 
 ! Wireless Meter Resources
 
-xosview*wireless:            True
-xosview*PoorQualityColor:    red
-xosview*FairQualityColor:    orange
-xosview*GoodQualityColor:    seagreen
-xosview*wirelessUsedColor:   aquamarine
-xosview*wirelessPriority:    1
-xosview*wirelessUsedFormat:  autoscale
-xosview*wirelessDecay:       True
+*wireless:            True
+*PoorQualityColor:    red
+*FairQualityColor:    yellow
+*GoodQualityColor:    green2
+*wirelessUsedColor:   blue
+*wirelessPriority:    1
+*wirelessUsedFormat:  autoscale
+*wirelessDecay:       True
 
 ! Disk Meter Resources
 
-xosview*disk:		    True
-xosview*diskUsedColor:	    seagreen
-xosview*diskIdleColor:	    aquamarine
-xosview*diskWriteColor:     SlateBlue1
-xosview*diskReadColor:      SkyBlue
-xosview*diskBandwidth:      100000000 ! 100MB/s
-xosview*diskPriority:	    10
-xosview*diskDecay:	    True
-xosview*diskUsedFormat:     autoscale
-xosview*diskGraph:	    True
-
-
-xosview*RAID:                 False
-xosview*RAIDdevicecount:      1
-xosview*RAIDdiskOnlineColor:  green
-xosview*RAIDdiskFailureColor: red
-xosview*RAIDresyncdoneColor:  yellow
-xosview*RAIDresynctodoColor:  red
-xosview*RAIDresynccompleteColor:  green
-xosview*RAIDPriority:         20
-xosview*RAIDUsedFormat:       percent
-
-xosview*horizontalMargin:      5
-xosview*verticalMargin:        5
-xosview*verticalSpacing:       5
+*disk:		    True
+*diskUsedColor:	    red
+*diskIdleColor:	    green2
+*diskWriteColor:     orange
+*diskReadColor:      blue
+*diskBandwidth:      100000000 ! 100MB/s
+*diskPriority:	    10
+*diskDecay:	    True
+*diskUsedFormat:     autoscale
+*diskGraph:	    True
+
+
+*RAID:                 False
+*RAIDdevicecount:      1
+*RAIDdiskOnlineColor:  green2
+*RAIDdiskFailureColor: red
+*RAIDresyncdoneColor:  yellow
+*RAIDresynctodoColor:  red
+*RAIDresynccompleteColor:  orange
+*RAIDPriority:         20
+*RAIDUsedFormat:       percent
+
+*horizontalMargin:      5
+*verticalMargin:        5
+*verticalSpacing:       5
 
 ! Lms Temp
-xosview*lmstemp:	False
-xosview*lmstempActColor:	blue
-xosview*lmstempHighColor:	red
-xosview*lmstempLowColor:       orange
-xosview*lmstempIdleColor:      aquamarine
-xosview*lmstempPriority: 20
-xosview*lmstempUsedFormat: autoscale
-! xosview*lmstemp1:	temp
-! xosview*lmstemp2:	remote_temp
+*lmstemp:	False
+*lmstempActColor:	blue
+*lmstempHighColor:	red
+*lmstempLowColor:       orange
+*lmstempIdleColor:      green2
+*lmstempPriority: 20
+*lmstempUsedFormat: autoscale
+! *lmstemp1:	temp
+! *lmstemp2:	remote_temp
 ! for more sensors just add entries here
 ! note, to configure sensors with same name in different subdirs,
 ! use absolute paths
 ! labels for above sensors (default = TMP)
-! xosview*lmstempLabel1:    TMP
-! xosview*lmstempLabel2:	RTMP
+! *lmstempLabel1:    TMP
+! *lmstempLabel2:	RTMP
 
-xosview*NFSDStats:       False
-xosview*NFSDStatCallsColor:     green
-xosview*NFSDStatBadCallsColor: red
-xosview*NFSDStatUDPColor:       yellow
-xosview*NFSDStatTCPColor:       orange
-xosview*NFSDStatIdleColor:      aquamarine
-xosview*NFSDStatDecay:		True
-xosview*NFSDStatGraph:		False
-xosview*NFSDStatUsedFormat:	percent
-
-xosview*NFSStats:       False
-xosview*NFSStatReTransColor:    red
-xosview*NFSStatAuthRefrshColor: yellow
-xosview*NFSStatCallsColor:      SkyBlue
-xosview*NFSStatIdleColor:       aquamarine
-xosview*NFSStatDecay:		True
-xosview*NFSStatGraph:		False
-xosview*NFSStatUsedFormat:	percent
-
-xosview*acpitemp:                 False
-xosview*acpitempActColor:         blue
-xosview*acpitempHighColor:        red
-xosview*acpitempIdleColor:        aquamarine
-xosview*acpitempPriority:         20
-xosview*acpitempUsedFormat:       float
-xosview*acpitempHighest:          100
-! xosview*acpitemp1:                CPU
-! xosview*acpitemp2:                MB
-
-xosview*coretemp:                 False
-xosview*coretempActColor:         blue
-xosview*coretempHighColor:        red
-xosview*coretempIdleColor:        aquamarine
-xosview*coretempPriority:         20
-xosview*coretempUsedFormat:       float
-xosview*coretempDisplayType:      separate    ! separate, maximum or average
-! xosview*coretemp1Package:         0
-
-xosview*bsdsensor:               False
-xosview*bsdsensorActColor:       blue
-xosview*bsdsensorHighColor:      red
-xosview*bsdsensorLowColor:       orange
-xosview*bsdsensorIdleColor:      aquamarine
-xosview*bsdsensorPriority:       20
-xosview*bsdsensorUsedFormat:     float
+*NFSDStats:       False
+*NFSDStatCallsColor:     green2
+*NFSDStatBadCallsColor: red
+*NFSDStatUDPColor:       yellow
+*NFSDStatTCPColor:       orange
+*NFSDStatIdleColor:      blue
+*NFSDStatDecay:		True
+*NFSDStatGraph:		False
+*NFSDStatUsedFormat:	percent
+
+*NFSStats:       False
+*NFSStatReTransColor:    SkyBlue3
+*NFSStatAuthRefrshColor: seagreen
+*NFSStatCallsColor:      green2
+*NFSStatIdleColor:       blue
+*NFSStatDecay:		True
+*NFSStatGraph:		False
+*NFSStatUsedFormat:	percent
+
+*acpitemp:                 False
+*acpitempActColor:         blue
+*acpitempHighColor:        red
+*acpitempIdleColor:        green2
+*acpitempPriority:         20
+*acpitempUsedFormat:       float
+*acpitempHighest:          100
+! *acpitemp1:                CPU
+! *acpitemp2:                MB
+
+*coretemp:                 False
+*coretempActColor:         blue
+*coretempHighColor:        red
+*coretempIdleColor:        green2
+*coretempPriority:         20
+*coretempUsedFormat:       float
+*coretempDisplayType:      separate    ! separate, maximum or average
+! *coretemp1Package:         0
+
+*bsdsensor:               False
+*bsdsensorActColor:       blue
+*bsdsensorHighColor:      red
+*bsdsensorLowColor:       orange
+*bsdsensorIdleColor:      green2
+*bsdsensorPriority:       20
+*bsdsensorUsedFormat:     float
 ! NetBSD example
-! xosview*bsdsensor1:              coretemp0.cur-value
+! *bsdsensor1:              coretemp0.cur-value
 ! OpenBSD example
-! xosview*bsdsensor1:              it0.temp1
-! xosview*bsdsensorLabel1:         CPU0
-! xosview*bsdsensorHigh1:          100
+! *bsdsensor1:              it0.temp1
+! *bsdsensorLabel1:         CPU0
+! *bsdsensorHigh1:          100
 
--- Xrmcommandline.h
+++ Xrmcommandline.h	2020-04-02 06:19:40.181330816 +0000
@@ -10,96 +10,96 @@ static XrmOptionDescRec options[] = {
 //    it is self-consistent, and self-explanatory.
 
 //  General, X11 resources:
-{ "-display", "*display", XrmoptionSepArg, (caddr_t) NULL },
-{ "-font", "*font", XrmoptionSepArg, (caddr_t) NULL },
-{ "-title", "*title", XrmoptionSepArg, (caddr_t) NULL },
-{ "-geometry", "*geometry", XrmoptionSepArg, (caddr_t) NULL },
-{ "-hmargin", "*horizontalMargin", XrmoptionSepArg, (caddr_t) NULL },
-{ "-vmargin", "*verticalMargin", XrmoptionSepArg, (caddr_t) NULL },
-{ "-vspacing", "*verticalSpacing", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-display", "*display", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-font", "*font", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-title", "*title", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-geometry", "*geometry", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-hmargin", "*horizontalMargin", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-vmargin", "*verticalMargin", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-vspacing", "*verticalSpacing", XrmoptionSepArg, (caddr_t) NULL },
 
 
 //  XOSView-specific resources:
-{ "-labels", "*labels", XrmoptionNoArg, "False" },
-{ "+labels", "*labels", XrmoptionNoArg, "True" },
-{ "-captions", "*captions", XrmoptionNoArg, "False" },
-{ "+captions", "*captions", XrmoptionNoArg, "True" },
-{ "-usedlabels", "*usedlabels", XrmoptionNoArg, "False" },
-{ "+usedlabels", "*usedlabels", XrmoptionNoArg, "True" },
-{ "-samplesPerSec", "*samplesPerSec", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-labels", "*labels", XrmoptionNoArg, "False" },
+{ (char*)"+labels", "*labels", XrmoptionNoArg, "True" },
+{ (char*)"-captions", "*captions", XrmoptionNoArg, "False" },
+{ (char*)"+captions", "*captions", XrmoptionNoArg, "True" },
+{ (char*)"-usedlabels", "*usedlabels", XrmoptionNoArg, "False" },
+{ (char*)"+usedlabels", "*usedlabels", XrmoptionNoArg, "True" },
+{ (char*)"-samplesPerSec", "*samplesPerSec", XrmoptionSepArg, (caddr_t) NULL },
 //  CPU resources
-{ "-cpu", "*cpu", XrmoptionNoArg, "False" },
-{ "+cpu", "*cpu", XrmoptionNoArg, "True" },
-{ "-cpus", "*cpuFormat", XrmoptionNoArg, "single" },
-{ "+cpus", "*cpuFormat", XrmoptionNoArg, "all" },
+{ (char*)"-cpu", "*cpu", XrmoptionNoArg, "False" },
+{ (char*)"+cpu", "*cpu", XrmoptionNoArg, "True" },
+{ (char*)"-cpus", "*cpuFormat", XrmoptionNoArg, "single" },
+{ (char*)"+cpus", "*cpuFormat", XrmoptionNoArg, "all" },
 // Load resources
-{ "-load", "*load", XrmoptionNoArg, "False" },
-{ "+load", "*load", XrmoptionNoArg, "True" },
+{ (char*)"-load", "*load", XrmoptionNoArg, "False" },
+{ (char*)"+load", "*load", XrmoptionNoArg, "True" },
 // Memmeter resources
-{ "-mem", "*mem", XrmoptionNoArg, "False" },
-{ "+mem", "*mem", XrmoptionNoArg, "True" },
+{ (char*)"-mem", "*mem", XrmoptionNoArg, "False" },
+{ (char*)"+mem", "*mem", XrmoptionNoArg, "True" },
 // Swapmeter resources
-{ "-swap", "*swap", XrmoptionNoArg, "False" },
-{ "+swap", "*swap", XrmoptionNoArg, "True" },
+{ (char*)"-swap", "*swap", XrmoptionNoArg, "False" },
+{ (char*)"+swap", "*swap", XrmoptionNoArg, "True" },
 // Batterymeter resources
-{ "-battery", "*battery", XrmoptionNoArg, "False" },
-{ "+battery", "*battery", XrmoptionNoArg, "True" },
+{ (char*)"-battery", "*battery", XrmoptionNoArg, "False" },
+{ (char*)"+battery", "*battery", XrmoptionNoArg, "True" },
 // Wirelessmeter resources
-{ "-wireless", "*wireless", XrmoptionNoArg, "False" },
-{ "+wireless", "*wireless", XrmoptionNoArg, "True" },
+{ (char*)"-wireless", "*wireless", XrmoptionNoArg, "False" },
+{ (char*)"+wireless", "*wireless", XrmoptionNoArg, "True" },
 //  GFX resources
-{ "-gfx", "*gfx", XrmoptionNoArg, "False" },
-{ "+gfx", "*gfx", XrmoptionNoArg, "True" },
+{ (char*)"-gfx", "*gfx", XrmoptionNoArg, "False" },
+{ (char*)"+gfx", "*gfx", XrmoptionNoArg, "True" },
 
 // Networkmeter resources
-{ "-net", "*net", XrmoptionNoArg, "False" },
-{ "+net", "*net", XrmoptionNoArg, "True" },
+{ (char*)"-net", "*net", XrmoptionNoArg, "False" },
+{ (char*)"+net", "*net", XrmoptionNoArg, "True" },
 //  Previously, network was overloaded to be the bandwidth and the
 //  on/off flag.  Now, we have -net for on/off, and networkBandwidth
 //  for bandwidth, with the alias networkBW, and network for backwards
 //  compatibility.
-{ "-network", "*netBandwidth", XrmoptionSepArg, (caddr_t) NULL },
-{ "-networkBW", "*netBandwidth", XrmoptionSepArg, (caddr_t) NULL },
-{ "-networkBandwidth", "*netBandwidth", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-network", "*netBandwidth", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-networkBW", "*netBandwidth", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-networkBandwidth", "*netBandwidth", XrmoptionSepArg, (caddr_t) NULL },
 
 // Page Meter
-{ "-page", "*page", XrmoptionNoArg, "False" },
-{ "+page", "*page", XrmoptionNoArg, "True" },
-{ "-pagespeed", "*pageBandWidth", XrmoptionSepArg, (caddr_t) NULL },
+{ (char*)"-page", "*page", XrmoptionNoArg, "False" },
+{ (char*)"+page", "*page", XrmoptionNoArg, "True" },
+{ (char*)"-pagespeed", "*pageBandWidth", XrmoptionSepArg, (caddr_t) NULL },
 
 #if !defined(__hpux__) && !defined(__hpux)
 //  Disk Meter Options
-{ "-disk", "*disk", XrmoptionNoArg, "False" },
-{ "+disk", "*disk", XrmoptionNoArg, "True" },
+{ (char*)"-disk", "*disk", XrmoptionNoArg, "False" },
+{ (char*)"+disk", "*disk", XrmoptionNoArg, "True" },
 #endif
 
 // Interrupt meter resources  --  all sorts of aliases.
-{ "-int", "*interrupts", XrmoptionNoArg, "False" },
-{ "+int", "*interrupts", XrmoptionNoArg, "True" },
-{ "-ints", "*interrupts", XrmoptionNoArg, "False" },
-{ "+ints", "*interrupts", XrmoptionNoArg, "True" },
-{ "-interrupts", "*interrupts", XrmoptionNoArg, "False" },
-{ "+interrupts", "*interrupts", XrmoptionNoArg, "True" },
+{ (char*)"-int", "*interrupts", XrmoptionNoArg, "False" },
+{ (char*)"+int", "*interrupts", XrmoptionNoArg, "True" },
+{ (char*)"-ints", "*interrupts", XrmoptionNoArg, "False" },
+{ (char*)"+ints", "*interrupts", XrmoptionNoArg, "True" },
+{ (char*)"-interrupts", "*interrupts", XrmoptionNoArg, "False" },
+{ (char*)"+interrupts", "*interrupts", XrmoptionNoArg, "True" },
 
 // Intrate meter resources, for platforms that support it.
-{ "-irqrate", "*irqrate", XrmoptionNoArg, "False" },
-{ "+irqrate", "*irqrate", XrmoptionNoArg, "True" },
-{ "-intrate", "*irqrate", XrmoptionNoArg, "False" },
-{ "+intrate", "*irqrate", XrmoptionNoArg, "True" },
+{ (char*)"-irqrate", "*irqrate", XrmoptionNoArg, "False" },
+{ (char*)"+irqrate", "*irqrate", XrmoptionNoArg, "True" },
+{ (char*)"-intrate", "*irqrate", XrmoptionNoArg, "False" },
+{ (char*)"+intrate", "*irqrate", XrmoptionNoArg, "True" },
 
 // lmstemp resources
-{ "-lmstemp", "*lmstemp", XrmoptionNoArg, "False" },
-{ "+lmstemp", "*lmstemp", XrmoptionNoArg, "True" },
+{ (char*)"-lmstemp", "*lmstemp", XrmoptionNoArg, "False" },
+{ (char*)"+lmstemp", "*lmstemp", XrmoptionNoArg, "True" },
 // coretemp resources
-{ "-coretemp", "*coretemp", XrmoptionNoArg, "False" },
-{ "+coretemp", "*coretemp", XrmoptionNoArg, "True" },
+{ (char*)"-coretemp", "*coretemp", XrmoptionNoArg, "False" },
+{ (char*)"+coretemp", "*coretemp", XrmoptionNoArg, "True" },
 // acpitemp resources
-{ "-acpitemp", "*acpitemp", XrmoptionNoArg, "False" },
-{ "+acpitemp", "*acpitemp", XrmoptionNoArg, "True" },
+{ (char*)"-acpitemp", "*acpitemp", XrmoptionNoArg, "False" },
+{ (char*)"+acpitemp", "*acpitemp", XrmoptionNoArg, "True" },
 
 //  Special, catch-all option here --
 //    xosview -xrm "*memFreeColor: purple" should work, for example.
-{ "-xrm", "*xrm", XrmoptionResArg, (caddr_t) NULL },
+{ (char*)"-xrm", "*xrm", XrmoptionResArg, (caddr_t) NULL },
 };
 //  This auto-detects changes in the number of options.
 static const int NUM_OPTIONS = sizeof(options) / sizeof(options[0]);
--- bitmeter.cc
+++ bitmeter.cc	2020-04-02 06:19:40.181330816 +0000
@@ -88,9 +88,9 @@ void BitMeter::draw( void ){
 
     int offset;
     if ( dousedlegends_ )
-      offset = parent_->textWidth( "XXXXXXXXXX" );
+      offset = parent_->textWidth( "XXXXXXXXXXX" );
     else
-      offset = parent_->textWidth( "XXXXXX" );
+      offset = parent_->textWidth( "XXXXXM" );
 
     parent_->drawString( x_ - offset + 1, y_ + height_, title_ );
     parent_->setForeground( onColor_ );
--- fieldmeter.cc
+++ fieldmeter.cc	2020-04-02 06:19:40.181330816 +0000
@@ -122,9 +122,9 @@ void FieldMeter::draw( void ){
 
     int offset;
     if ( dousedlegends_ )
-      offset = parent_->textWidth( "XXXXXXXXXX" );
+      offset = parent_->textWidth( "XXXXXXXXXXX" );
     else
-      offset = parent_->textWidth( "XXXXXX" );
+      offset = parent_->textWidth( "XXXXXM" );
 
     parent_->drawString( x_ - offset + 1, y_ + height_, title_ );
   }
--- linux/MeterMaker.cc
+++ linux/MeterMaker.cc	2020-04-02 06:19:40.181330816 +0000
@@ -137,6 +137,7 @@ void MeterMaker::makeMeters(void){
       }
 #endif
 
+#if !defined(__s390__) && !defined(__s390x__)
   // check for the interrupt meter
   if (_xos->isResourceTrue("interrupts")) {
     int cpuCount = IntMeter::countCPUs();
@@ -148,6 +149,7 @@ void MeterMaker::makeMeters(void){
     else
       push(new IntMeter(_xos, cpuCount-1));
   }
+#endif
 
   // check for irqrate meter
   if (_xos->isResourceTrue("irqrate"))
--- linux/diskmeter.cc
+++ linux/diskmeter.cc	2020-04-02 06:19:40.181330816 +0000
@@ -165,7 +165,7 @@ void DiskMeter::getvmdiskinfo(void)
     // read second value
     stats >> two;
 
-    updateinfo(one, two, 4);
+    updateinfo(one, two, 2);	// The factor is 2 and NOT 4
 }
 
 void DiskMeter::getdiskinfo( void )
--- llist.cc
+++ llist.cc	2020-04-02 06:19:40.181330816 +0000
@@ -232,24 +232,32 @@ void *LList::findc( int which ){
 }
 
 void LList::save( int size, FILE *fp ){
+  size_t r;
   int i;
   void *buf;
 
-  fwrite( &n_, sizeof( int ), 1, fp );	/*  save n  */
+  r = fwrite( &n_, sizeof( int ), 1, fp );	/*  save n  */
+  if (r != sizeof ( int ))
+    return ;
 
   setc( 1 );
   for ( i = 1 ; i <= n_ ; i ++ ) {
     buf = findc();
-    fwrite ( buf, size, 1, fp );
+    r = fwrite ( buf, size, 1, fp );
+    if (r != (size_t) size)
+      break;
     incc();
   }
 }
 
 int LList::restore( int size, FILE *fp ){
-  int i;
+  size_t r;
+  int i = 0;
   void *buf;
 
-  fread ( &i, sizeof ( int ), 1, fp );
+  r = fread ( &i, sizeof ( int ), 1, fp );
+  if (r != sizeof ( int ))
+    return ( 1 );
 
   for ( ; i > 0 ; i-- ) {
     if ( ( buf = new char[size] ) == NULL ) return ( 0 );
--- xosview.1
+++ xosview.1	2020-04-02 06:19:40.185330737 +0000
@@ -336,7 +336,7 @@ and \'purple\'):
 The following is a list of X resources supported by \fIxosview\fP.  Each has
 a default value assigned to it.  These values can be found in the file
 Xdefaults which can be obtained in the source distribution of xosview.
-They can be overridden in the usual places (/usr/lib/X11/app-defaults/XOsview,
+They can be overridden in the usual places (/usr/share/X11/app-defaults/XOsview,
 $HOME/.Xdefaults, etc.).
 
 It should be noted that it is OK to have a resource defined for a port of
--- xosview.cc
+++ xosview.cc	2020-04-02 06:19:40.185330737 +0000
@@ -11,6 +11,7 @@
       defined(XOSVIEW_OPENBSD) || defined(XOSVIEW_DFBSD) )
 # include "kernel.h"
 #endif
+#include <errno.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -160,9 +161,9 @@ void XOSView::checkVersion(int argc, cha
 void XOSView::figureSize ( void ) {
   if ( legend_ ){
     if ( !usedlabels_ )
-      xoff_ = textWidth( "XXXXXX" );
+      xoff_ = textWidth( "XXXXXM" );
     else
-      xoff_ = textWidth( "XXXXXXXXXX" );
+      xoff_ = textWidth( "XXXXXXXXXXX" );
 
     yoff_ = caption_ ? textHeight() + textHeight() / 4 : 0;
   }

Places

File xosview-1.19.dif of Package xosview (Revision d943fbcaecedc4d5e3477b35a0a9108c)

Places