Merge pull request #6 from qtc-de/dev

Prepare v1.4.0 Release

Author: qtc-de

CHANGELOG.md

@@ -6,6 +6,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 
+## v1.4.0 - Mar 29, 2025
+
+### Changed
+
+* Switch from `vweb` to `veb` module
+* Switch from `x.json2` to `json` module
+* Get rid of global variables
+
+
 ## v1.3.0 - July 29, 2024
 
 ### Added

Makefile

@@ -3,7 +3,7 @@ RES := resources/rpv-web.res
 ICON := resources/rpv-web.ico
 ICON86 := resources/rpv-web-x86.ico
 ICON64 := resources/rpv-web-x64.ico
-Options := -os windows -prod -enable-globals -cflags $(shell pwd)/${RES}
+Options := -os windows -prod -cflags $(shell pwd)/${RES}
 DebugOptions := ${Options} -d debug
 
 rpv-web-x64 x64: ${RC}

frontend/src/components/Headline.vue

@@ -374,7 +374,7 @@
             <p id="Logo" class="d-inline-block">RP</p>
             <img id="LogoPng" src="../assets/icons/rpv-web.png"/>
             <p id="Web" class="d-inline-block">WEB</p>
-            <p class="Fs-8 mb-0 ml-4">v1.3.0</p>
+            <p class="Fs-8 mb-0 ml-4">v1.4.0</p>
         </div>
 
         <div id="RightHeadline">

src/app.v

@@ -0,0 +1,173 @@
+module main
+
+import os
+import qtc_de.rpv
+
+
+// refresh obtains RPC information for currently running processes and stores
+// them within the internal context. If RPC information is already available, the
+// method attempts first to renew the already existing RPC info instead of requesting
+// new data.
+//
+// The method obtains a list of currently running process ids and iterates over them.
+// For each PID where an RpvProcessInformation is already present, it calls the update
+// method. For other processes, RpvProcessInformation is obtained via get_rpv_process_info.
+//
+// The method uses a global context and is currently not thread safe.
+fn (mut app App) refresh()!
+{
+	self_pid := os.getpid()
+
+	arr_size := u32(0)
+	mut pids := []u32{len: 1024}
+
+	if !C.EnumProcesses(pids.data, u32(pids.cap) * sizeof(u32), &arr_size)
+	{
+		return error('Failed to enumerate processes.')
+	}
+
+	pids.trim(int(arr_size / sizeof(u32)))
+	mut rpv_infos := []rpv.RpvProcessInformation{cap: int(arr_size / sizeof(u32)) - 1}
+
+	pid_loop:
+	for pid in pids
+	{
+		if pid == self_pid
+		{
+			continue
+		}
+
+		for mut web_info in app.processes
+		{
+			if web_info.pid == pid
+			{
+				web_info.rpv_info.update(mut app.symbol_resolver) or { break }
+				rpv_infos << web_info.rpv_info
+				continue pid_loop
+			}
+		}
+
+		if rpv_process_info := rpv.get_rpv_process_info(pid, mut app.symbol_resolver)
+		{
+			rpv_infos << rpv_process_info
+		}
+	}
+
+	app.processes.clear()
+
+	for info in rpv_infos
+	{
+		app.processes << convert_rpv_process_info(info, mut app.icon_cache, app.symbol_resolver)
+	}
+
+	for child in app.processes
+	{
+		for mut parent in app.processes
+		{
+			if child.ppid == parent.pid
+			{
+				parent.childs << child
+			}
+		}
+	}
+}
+
+// get_process returns the RpvWebProcessInformation associated with
+// the specified pid. The pid is looked up in the global process array.
+pub fn (app &App) get_process(pid u32)? RpvWebProcessInformation
+{
+	for ctr := 0; ctr < app.processes.len; ctr++
+	{
+		if app.processes[ctr].pid == pid
+		{
+			return app.processes[ctr]
+		}
+	}
+
+	return none
+}
+
+// get_interface returns the RpvWebInterfaceInfo associated with the
+// specified pid und interface uuid. The pid is looked up within the
+// global interface array. The uuid is looked up within the rpc_info
+// of the corresponding process.
+pub fn (app &App) get_interface(pid u32, uuid string)? RpcWebInterfaceInfo
+{
+	process := app.get_process(pid) or
+	{
+		return none
+	}
+
+	for ctr := 0; ctr < process.rpc_info.interface_infos.len; ctr++
+	{
+		if process.rpc_info.interface_infos[ctr].id == uuid
+		{
+			return process.rpc_info.interface_infos[ctr]
+		}
+	}
+
+	return none
+}
+
+// get_rpv_interface returns the rpv.RpcInterfaceInfo that is associated
+// with the specified pid and interface uuid. rpv.RpcInterfaceInfo contains
+// the full low level details of the RpcServer and can be used to e.g.
+// decompile the available functions. However, it should not be returned
+// within webserver responses, as it contains binary data.
+pub fn (app &App) get_rpv_interface(pid u32, uuid string)? rpv.RpcInterfaceInfo
+{
+	process := app.get_process(pid) or
+	{
+		return none
+	}
+
+	for ctr := 0; ctr < process.rpv_info.rpc_info.interface_infos.len; ctr++
+	{
+		if process.rpv_info.rpc_info.interface_infos[ctr].id == uuid
+		{
+			return process.rpv_info.rpc_info.interface_infos[ctr]
+		}
+	}
+
+	return none
+}
+
+
+// take_snapshot iterates over all objects within the global process array to
+// calculate their child relationship and to decompile their RPC interfaces.
+// All this information is stored in a WebSnapshot struct that is returned to
+// the caller.
+pub fn (app &App) take_snapshot() WebSnapshot
+{
+	mut childs := []u32{cap: app.processes.len}
+
+	for process in app.processes
+	{
+		for child in process.childs
+		{
+			childs << child.pid
+		}
+	}
+
+	mut process_tree := []RpvWebProcessInformation{cap: app.processes.len - childs.len}
+	mut idl_data := []WebIdlInterface{cap: app.processes.len}
+
+	for process in app.processes
+	{
+		if !childs.contains(process.pid)
+		{
+			process_tree << process
+		}
+
+		for intf_info in process.rpv_info.rpc_info.interface_infos
+		{
+			midl_interface := intf_info.decode_all_methods(process.pid) or { continue }
+			idl_data << convert_rpv_midl_interface(midl_interface)
+		}
+	}
+
+	return WebSnapshot {
+		processes: process_tree
+		idl_data: idl_data
+	}
+}

src/main.v

@@ -1,61 +1,77 @@
 module main
 
 import os
+import veb
 import json
-import vweb
 import time
 import qtc_de.rpv
 import qtc_de.rpv.win
 import cli { Command, Flag }
 
-// In the current state of vweb, we have to use globals to track our
-// in memory state. Tracking this state within the App context does
-// currently not work correctly. Using a dedicated solution like an
-// sqlite database seems to be an overkill. Therefore, we use globals
-// as a temporary workaround.
-__global (
-	g_icon_cache win.IconCache
-	g_settings RpvWebSettings
-	g_processes []RpvWebProcessInformation
-	g_symbol_resolver rpv.SymbolResolver
-)
-
-struct App {
-	vweb.Context
+
+pub struct Context
+{
+	veb.Context
 }
 
-struct RpvWebSettings {
+pub struct App
+{
+	veb.StaticHandler
+pub mut:
+	refresh_error		string = 'Error while refreshing the process list.'
+	icon_cache			win.IconCache
+	settings			RpvWebSettings
+	processes			[]RpvWebProcessInformation
+	symbol_resolver		rpv.SymbolResolver
+}
+
+struct RpvWebSettings
+{
 	symbol_file string
-	mut:
+mut:
 	symbol_path string
 }
 
-pub fn (app App) before_request()
+pub fn (ctx Context) before_request()
 {
-	println('[web] Incoming request: ${app.req.method} ${app.req.url}')
+	println('[web] Incoming request: ${ctx.req.method} ${ctx.req.url}')
 }
 
 fn main()
 {
 	mut app := &App{}
 
-	app.serve_static('/favicon.ico', 'dist/favicon.ico')
-	app.serve_static('/', 'dist/index.html')
-	app.handle_static('dist', true)
+	app.serve_static('/favicon.ico', 'dist/favicon.ico') or
+	{
+		println('[-] Unable to serve favicon.ico')
+		return
+	}
+
+	app.serve_static('/', 'dist/index.html') or
+	{
+		println('[-] Unable to serve index.html')
+		return
+	}
+
+	app.handle_static('dist', true) or
+	{
+		println('[-] Unable to serve dist folder')
+		return
+	}
 
 	mut cmd := cli.Command
 	{
 		name: 'rpv-web'
-		description: 'An API interface to rpv'
-		version: '1.3.0'
+		description: 'An web API interface to rpv'
+		version: '1.4.0'
 		execute: fn [mut app] (cmd cli.Command)!
 		{
 			snapshot := cmd.flags.get_bool('snapshot') or { false }
 			symbol_file := cmd.flags.get_string('symbol-file') or { 'rpv-web-symbols.toml' }
 			pdb_path := cmd.flags.get_string('pdb-path') or { '' }
 
-			g_settings = RpvWebSettings { symbol_file: symbol_file, symbol_path: pdb_path }
-			g_symbol_resolver = rpv.new_resolver(g_settings.symbol_file, g_settings.symbol_path) or
+			app.settings = RpvWebSettings { symbol_file: symbol_file, symbol_path: pdb_path }
+			app.symbol_resolver = rpv.new_resolver(app.settings.symbol_file, app.settings.symbol_path) or
 			{
 				eprintln('[-] Unable to initialize global symbol resolver: ${err}')
 				return
@@ -72,7 +88,7 @@ fn main()
 				}
 
 				println('[+] Taking a snapshot.')
-				snap := take_snapshot()
+				snap := app.take_snapshot()
 
 				filename := '${time.now().strftime('%Y.%m.%d-%H.%M')}-rpv-web-snapshot.json'
 				println('[+] Writing result to ${filename}.')
@@ -86,7 +102,7 @@ fn main()
 			else
 			{
 				port := cmd.flags.get_int('port') or { 8000 }
-				vweb.run(app, port)
+				veb.run[App, Context](mut app, port)
 			}
 		}
 	}