533 lines
28 KiB
Rust
533 lines
28 KiB
Rust
//! One reviewed development bootstrap: normal stop of the exact old agent,
|
|
//! while an existing SQLite reservation excludes a new Sync/permit journal
|
|
//! commit. No job, approval, SQL row change, helper stop, reset or force kill.
|
|
#[cfg(all(windows, feature = "system-helper"))]
|
|
mod platform {
|
|
use anyhow::{Context, Result, ensure};
|
|
use prost::Message;
|
|
use rmm_agent_core::{
|
|
auth::{Binding, Outcome, Request},
|
|
crypto::DalekVerifier,
|
|
helper_reconcile::SignedResponse,
|
|
reconcile::{Channel, verify_response_with},
|
|
};
|
|
use rmm_agent_windows::{
|
|
helper_ipc::{self as ipc, PeerProof, PinnedFile},
|
|
native,
|
|
};
|
|
use rmm_domain::{jobs::hash, reconciliation::ReconcileDecisionPayload};
|
|
use rmm_protocol::{SyncRequest, SyncResponse,Envelope,Payload};
|
|
use rusqlite::{Connection, OpenFlags};
|
|
use serde_json::json;
|
|
use std::{
|
|
fs::{File, OpenOptions},
|
|
io::{Read, Write},
|
|
mem::{size_of, zeroed},
|
|
os::windows::fs::OpenOptionsExt,
|
|
path::Path,
|
|
ptr,
|
|
time::{Duration, Instant},
|
|
};
|
|
use uuid::Uuid;
|
|
use windows_sys::Win32::{
|
|
Foundation::*, Security::*, Storage::FileSystem::*, System::Services::*,
|
|
};
|
|
const AGENT: &str = "9651b2e518b315029cebfa432261a57f0a305aeddde29c56ac22a5ccbc417b32";
|
|
const HELPER: &str = "59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e";
|
|
const PIN: &str = "9d46dffe88f565b8b04554335d9669f5c83211b32419908a579b1cd4560443ec";
|
|
const SETTINGS: &str = "4c073cd3d4badb09d8c0f1c270b4cee9df533df416550f68bf3e336e3da7673c";
|
|
const CONFIG: &str = "5cd4cb9802d0dd20b961de7e3cd4e5874a1e9a72fc57b577e075e2d2918baac6";
|
|
const CASE: &str = "c6c80ac4-a52e-4b69-8170-466bcf52049d";
|
|
const JOB: &str = "0a50aae9-a784-4535-b62f-ef24c301d546";
|
|
const ATTEMPT: &str = "78295f74-4565-459a-87b0-641a8b95feec";
|
|
const AGENT_STATE: &str = r"C:\ProgramData\RustDiscovery\state";
|
|
const HELPER_STATE: &str = r"C:\ProgramData\RustDiscoverySystem\state";
|
|
struct Handle(SC_HANDLE);
|
|
impl Drop for Handle {
|
|
fn drop(&mut self) {
|
|
unsafe {
|
|
CloseServiceHandle(self.0);
|
|
}
|
|
}
|
|
}
|
|
fn admin() -> Result<()> {
|
|
let mut sid = [0usize; 16];
|
|
let mut len = std::mem::size_of_val(&sid) as u32;
|
|
let mut member = 0;
|
|
ensure!(
|
|
unsafe {
|
|
CreateWellKnownSid(
|
|
WinBuiltinAdministratorsSid,
|
|
ptr::null_mut(),
|
|
sid.as_mut_ptr().cast(),
|
|
&mut len,
|
|
)
|
|
} != 0
|
|
&& unsafe {
|
|
CheckTokenMembership(ptr::null_mut(), sid.as_mut_ptr().cast(), &mut member)
|
|
} != 0
|
|
&& member != 0,
|
|
"QUIESCENT_ADMIN_REQUIRED"
|
|
);
|
|
Ok(())
|
|
}
|
|
fn service(stop:bool) -> Result<Handle> {
|
|
let manager =
|
|
Handle(unsafe { OpenSCManagerW(ptr::null(), ptr::null(), SC_MANAGER_CONNECT) });
|
|
ensure!(!manager.0.is_null(), "QUIESCENT_SCM_MANAGER");
|
|
let h = Handle(unsafe {
|
|
OpenServiceW(
|
|
manager.0,
|
|
ipc::wide(rmm_agent_windows::SERVICE_NAME).as_ptr(),
|
|
SERVICE_QUERY_STATUS | SERVICE_QUERY_CONFIG | if stop {SERVICE_STOP}else{0},
|
|
)
|
|
});
|
|
ensure!(!h.0.is_null(), "QUIESCENT_SCM_AGENT");
|
|
Ok(h)
|
|
}
|
|
fn status(h: &Handle) -> Result<SERVICE_STATUS_PROCESS> {
|
|
let mut s = unsafe { zeroed() };
|
|
let mut n = 0;
|
|
ensure!(
|
|
unsafe {
|
|
QueryServiceStatusEx(
|
|
h.0,
|
|
SC_STATUS_PROCESS_INFO,
|
|
(&mut s as *mut SERVICE_STATUS_PROCESS).cast(),
|
|
size_of::<SERVICE_STATUS_PROCESS>() as u32,
|
|
&mut n,
|
|
)
|
|
} != 0,
|
|
"QUIESCENT_SCM_STATUS"
|
|
);
|
|
Ok(s)
|
|
}
|
|
fn protected(path: &Path, readers: &[String], expected: &str) -> Result<(PinnedFile, Vec<u8>)> {
|
|
let mut file = PinnedFile::open(path, false, readers, &[], false)?;
|
|
ensure!(
|
|
file.file.metadata()?.len() <= 65536,
|
|
"QUIESCENT_PUBLIC_FILE_LIMIT"
|
|
);
|
|
let mut raw = Vec::new();
|
|
(&mut file.file).take(65537).read_to_end(&mut raw)?;
|
|
ensure!(
|
|
raw.len() <= 65536 && hash(&raw) == expected,
|
|
"QUIESCENT_PUBLIC_HASH"
|
|
);
|
|
file.check()?;
|
|
Ok((file, raw))
|
|
}
|
|
fn hold_agent(path: &Path) -> Result<File> {
|
|
native::private_path(path, false)?;
|
|
Ok(OpenOptions::new()
|
|
.read(true)
|
|
.share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE)
|
|
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT)
|
|
.open(path)?)
|
|
}
|
|
fn check_id(file: &File, path: &Path) -> Result<()> {
|
|
let actual = hold_agent(path)?;
|
|
ensure!(
|
|
ipc::file_identity(file)? == ipc::file_identity(&actual)?,
|
|
"QUIESCENT_DATABASE_REPLACED"
|
|
);
|
|
Ok(())
|
|
}
|
|
fn receipt(dir: &Path, name: &str, value: &serde_json::Value) -> Result<()> {
|
|
let bytes = serde_json::to_vec(value)?;
|
|
ensure!(bytes.len() <= 16384, "QUIESCENT_RECEIPT_LIMIT");
|
|
let path = dir.join(name);
|
|
let mut f = OpenOptions::new()
|
|
.write(true)
|
|
.create_new(true)
|
|
.share_mode(FILE_SHARE_READ)
|
|
.custom_flags(FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_WRITE_THROUGH)
|
|
.open(&path)?;
|
|
f.write_all(&bytes)?;
|
|
f.sync_all()?;
|
|
drop(f);
|
|
let mut read = PinnedFile::open(&path, false, &[], &[], false)?;
|
|
ensure!(read.sha256()? == hash(&bytes), "QUIESCENT_RECEIPT_READBACK");
|
|
Ok(())
|
|
}
|
|
struct Idle {
|
|
decision: Uuid,
|
|
checkpoint: u64,
|
|
helper_checkpoint: u64,
|
|
request_sha256: String,
|
|
response_sha256: String,
|
|
original_echo_job: Uuid,
|
|
pending_request:Option<String>,
|
|
pending_request_sha256:Option<String>,
|
|
}
|
|
fn idle(
|
|
db: &Connection,
|
|
consumption: &Connection,
|
|
helper: &Connection,
|
|
intents: &Connection,
|
|
binding: &Binding,
|
|
) -> Result<Idle> {
|
|
let (journal,checkpoint,generation,last,pending,helper_id,helper_cp,fault):(String,u64,u64,String,Option<String>,String,u64,Option<String>)=db.query_row("SELECT journal_id,checkpoint,generation,last_decision,pending_request,helper_id,helper_checkpoint,fault FROM reconcile_meta WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?,r.get(4)?,r.get(5)?,r.get(6)?,r.get(7)?)))?;
|
|
ensure!(fault.is_none(),"QUIESCENT_AGENT_FAULT");
|
|
let (helper_journal, helper_last, helper_fault,helper_agent_cp): (String, String, Option<String>,u64) = helper
|
|
.query_row(
|
|
"SELECT journal_id,last_decision,fault,agent_checkpoint FROM helper_sync_meta WHERE id=1",
|
|
[],
|
|
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?,r.get(3)?)),
|
|
)?;
|
|
ensure!(
|
|
helper_fault.is_none() && helper_last == last && helper_journal == helper_id,
|
|
"QUIESCENT_HELPER_HEAD_DIFFERS"
|
|
);
|
|
let (raw_response, raw_request, applied_cp): (Vec<u8>, Vec<u8>, u64) = helper.query_row(
|
|
"SELECT response,request,checkpoint FROM helper_sync_decisions WHERE decision_id=?1",
|
|
[&last],
|
|
|r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
|
|
)?;
|
|
ensure!(
|
|
applied_cp == helper_cp,
|
|
"QUIESCENT_HELPER_APPLIED_CHECKPOINT"
|
|
);
|
|
let signed: SignedResponse = serde_json::from_slice(&raw_response)?;
|
|
let parsed: ReconcileDecisionPayload = serde_json::from_slice(&signed.decision_bytes)?;
|
|
let (agent_request, agent_response): (Vec<u8>, Vec<u8>) = db.query_row(
|
|
"SELECT request,response FROM reconcile_requests WHERE id=?1",
|
|
[parsed.request_id.to_string()],
|
|
|r| Ok((r.get(0)?, r.get(1)?)),
|
|
)?;
|
|
let response = SyncResponse::decode(agent_response.as_slice())?;
|
|
let request = SyncRequest::decode(agent_request.as_slice())?;
|
|
ensure!(
|
|
raw_request == agent_request
|
|
&& signed.decision_bytes == response.decision_bytes
|
|
&& signed.signature == response.signature,
|
|
"QUIESCENT_RAW_SIGNED_CONTROL_DIFFERS"
|
|
);
|
|
let verified = verify_response_with(
|
|
&DalekVerifier,
|
|
binding,
|
|
&request,
|
|
&Channel {
|
|
connection_generation: parsed.connection_generation,
|
|
boot_id: parsed.boot_id,
|
|
},
|
|
&response,
|
|
parsed.issued_at,
|
|
)?;
|
|
ensure!(
|
|
verified.decision_id.to_string() == last
|
|
&& verified.journal_id.to_string() == journal
|
|
&& verified.checkpoint == helper_agent_cp
|
|
&& verified.checkpoint<=checkpoint
|
|
&& verified.connection_generation<=generation
|
|
&& verified.helper_journal_id.map(|id| id.to_string()) == Some(helper_id.clone())
|
|
&& verified.helper_checkpoint == helper_cp
|
|
&& verified.ready
|
|
&& verified.helper_ready
|
|
&& verified.reason == "CONSISTENT",
|
|
"QUIESCENT_SIGNED_HEAD_BINDING"
|
|
);
|
|
let pending_request=if let Some(id)=pending.as_ref() {
|
|
let (request_raw,envelope_raw,row_generation,response):(Vec<u8>,Vec<u8>,u64,Option<Vec<u8>>)=db.query_row("SELECT request,envelope,generation,response FROM reconcile_requests WHERE id=?1",[id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?,r.get(3)?)))?;
|
|
ensure!(response.is_none() && request_raw.len()<=rmm_domain::MAX_MESSAGE && envelope_raw.len()<=rmm_domain::MAX_MESSAGE,"QUIESCENT_ONLY_UNRESPONDED_CONTROL");
|
|
let request=SyncRequest::decode(request_raw.as_slice())?;
|
|
let envelope=Envelope::decode(envelope_raw.as_slice())?;
|
|
ensure!(request.encode_to_vec()==request_raw && envelope.encode_to_vec()==envelope_raw
|
|
&& request.request_id==*id && request.journal_id==journal && request.checkpoint==checkpoint
|
|
&& request.previous_decision_id==last && request.helper_previous_decision_id==last
|
|
&& request.helper_journal_id==helper_id && request.helper_checkpoint>=helper_cp
|
|
&& request.assignment_version==binding.assignment_version && request.journal_complete
|
|
&& request.durable_message_ids.is_empty() && request.attempts.len()==2
|
|
&& row_generation==generation && envelope.connection_generation==generation
|
|
&& envelope.agent_id==binding.agent_id.to_string() && envelope.enrollment_generation==binding.enrollment_generation
|
|
&& envelope.boot_id==verified.boot_id.to_string() && envelope.sequence==checkpoint
|
|
&& rmm_protocol::valid_envelope(&envelope,&binding.agent_id.to_string(),generation)
|
|
&& matches!(envelope.payload,Some(Payload::SyncRequest(ref body)) if body==&request),"QUIESCENT_PENDING_CONTROL_BINDING");
|
|
Some(request)
|
|
}else {
|
|
ensure!(verified.checkpoint==checkpoint && verified.connection_generation==generation,"QUIESCENT_WITHOUT_PENDING_EXACT_HEAD");
|
|
None
|
|
};
|
|
let busy:bool=db.query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying','unknown','awaiting_reboot'))",[],|r|r.get(0))?;
|
|
ensure!(!busy, "QUIESCENT_EFFECT_PENDING");
|
|
let (scope, original) = rmm_agent_windows::echo_probe::archive(db, binding)?
|
|
.context("QUIESCENT_ECHO_ARCHIVE_MISSING")?;
|
|
ensure!(
|
|
rmm_agent_windows::echo_completion::installed(db, binding, &scope, &original)?,
|
|
"QUIESCENT_ECHO_COMPLETION_MISSING"
|
|
);
|
|
let (total,echo,pending_new):(u64,u64,u64)=db.query_row("SELECT count(*),sum(job=?1 AND attempt=?2 AND state='succeeded'),sum(job=?3 AND attempt=?4 AND state IN ('accepted','expired') AND grant_id='') FROM job_attempts",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string(),JOB,ATTEMPT],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
|
|
ensure!(
|
|
total == 2 && echo == 1 && pending_new == 1,
|
|
"QUIESCENT_EXPECTED_TWO_JOB_HISTORY"
|
|
);
|
|
if let Some(request)=&pending_request {
|
|
let echo=request.attempts.iter().filter(|r|r.job_id==scope.job_id.to_string() && r.attempt_id==scope.attempt_id.to_string()).collect::<Vec<_>>();
|
|
let new=request.attempts.iter().filter(|r|r.job_id==JOB && r.attempt_id==ATTEMPT).collect::<Vec<_>>();
|
|
ensure!(echo.len()==1 && new.len()==1,"QUIESCENT_PENDING_EXPECTED_ATTEMPTS");
|
|
let old=echo[0];let new=new[0];
|
|
let old_grant:String=db.query_row("SELECT grant_id FROM job_attempts WHERE job=?1 AND attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|r.get(0))?;
|
|
ensure!(old.state=="succeeded" && old.consumption=="consumed" && old.grant_id==old_grant
|
|
&& !old.grant_id.is_empty() && old.job_payload_hash==scope.job_payload_hash && old.update_handoff_bytes.is_empty()
|
|
&& matches!(new.state.as_str(),"accepted"|"expired") && new.consumption=="unconsumed" && new.grant_id.is_empty()
|
|
&& new.update_handoff_bytes.is_empty(),"QUIESCENT_PENDING_NO_NEW_EFFECT");
|
|
}
|
|
let (total, new): (u64, u64) = consumption.query_row(
|
|
"SELECT count(*),COALESCE(sum(job=?1 OR attempt=?2),0) FROM consumed",
|
|
[JOB, ATTEMPT],
|
|
|r| Ok((r.get(0)?, r.get(1)?)),
|
|
)?;
|
|
ensure!(total == 1 && new == 0, "QUIESCENT_CONSUMPTION_CHANGED");
|
|
let (start,outcome,finished):(Vec<u8>,Vec<u8>,Vec<u8>)=consumption.query_row("SELECT e.start,e.outcome,c.result FROM consumed c JOIN execution_evidence e USING(grant_id) WHERE c.job=?1 AND c.attempt=?2",rusqlite::params![scope.job_id.to_string(),scope.attempt_id.to_string()],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?)))?;
|
|
let start: serde_json::Value = serde_json::from_slice(&start)?;
|
|
let request: Request = serde_json::from_value(start["request"].clone())?;
|
|
let at = serde_json::from_value(start["reserved_at"].clone())?;
|
|
let (job, _) = binding.verify_with(&request, at, &DalekVerifier)?;
|
|
let o: Outcome = serde_json::from_slice(&outcome)?;
|
|
ensure!(
|
|
scope.matches_job(&job)
|
|
&& o.state == "succeeded"
|
|
&& o.evidence["postconditions_passed"] == true
|
|
&& outcome == finished,
|
|
"QUIESCENT_ORIGINAL_ECHO_EVIDENCE"
|
|
);
|
|
ensure!(
|
|
helper.query_row("SELECT count(*) FROM consumed", [], |r| r.get::<_, u64>(0))? == 0
|
|
&& intents.query_row("SELECT count(*) FROM system_intents", [], |r| r
|
|
.get::<_, u64>(0))?
|
|
== 0,
|
|
"QUIESCENT_HELPER_WORK_PRESENT"
|
|
);
|
|
Ok(Idle {
|
|
decision: verified.decision_id,
|
|
checkpoint,
|
|
helper_checkpoint: helper_cp,
|
|
request_sha256: hash(&raw_request),
|
|
response_sha256: hash(&raw_response),
|
|
original_echo_job: scope.job_id,
|
|
pending_request:pending,
|
|
pending_request_sha256:pending_request.as_ref().map(|r|hash(&r.encode_to_vec())),
|
|
})
|
|
}
|
|
fn safe_error(error:&anyhow::Error)->serde_json::Value {
|
|
for cause in error.chain() {
|
|
let text=cause.to_string();
|
|
if text.starts_with("QUIESCENT_") && text.bytes().all(|b|b.is_ascii_uppercase()||b==b'_') {return json!({"code":text});}
|
|
if let Some(sql)=cause.downcast_ref::<rusqlite::Error>() {
|
|
return match sql {
|
|
rusqlite::Error::SqliteFailure(code,_)=>json!({"code":"SQLITE_FAILURE","sqlite_code":format!("{:?}",code.code),"extended_code":code.extended_code}),
|
|
rusqlite::Error::QueryReturnedNoRows=>json!({"code":"SQLITE_NO_ROWS"}),
|
|
rusqlite::Error::InvalidColumnIndex(index)=>json!({"code":"SQLITE_COLUMN_INDEX","index":index}),
|
|
rusqlite::Error::InvalidColumnType(index,column,_)=>json!({"code":"SQLITE_COLUMN_TYPE","index":index,"column":column}),
|
|
_=>json!({"code":"SQLITE_READ_FAILED"}),
|
|
};
|
|
}
|
|
}
|
|
json!({"code":"SIGNED_OR_ARCHIVED_EVIDENCE_CHECK_FAILED"})
|
|
}
|
|
fn safe_metadata(db:&Connection,consumed:&Connection,helper:&Connection,intents:&Connection)->Result<serde_json::Value> {
|
|
let agent=db.query_row("SELECT checkpoint,generation,last_decision,pending_request,helper_checkpoint,fault IS NOT NULL FROM reconcile_meta WHERE id=1",[],|r|Ok(json!({
|
|
"checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"pending_request":r.get::<_,Option<String>>(3)?,"helper_checkpoint":r.get::<_,u64>(4)?,"fault_present":r.get::<_,bool>(5)?})))?;
|
|
let helper_meta=helper.query_row("SELECT checkpoint,generation,last_decision,fault IS NOT NULL,agent_checkpoint FROM helper_sync_meta WHERE id=1",[],|r|Ok(json!({
|
|
"current_capture_checkpoint":r.get::<_,u64>(0)?,"generation":r.get::<_,u64>(1)?,"last_decision":r.get::<_,Option<String>>(2)?,"fault_present":r.get::<_,bool>(3)?,"agent_checkpoint":r.get::<_,u64>(4)?})))?;
|
|
let mut q=db.prepare("SELECT job,attempt,state,grant_id<>'' FROM job_attempts ORDER BY job LIMIT 8")?;
|
|
let jobs=q.query_map([],|r|Ok(json!({"job_id":r.get::<_,String>(0)?,"attempt_id":r.get::<_,String>(1)?,"state":r.get::<_,String>(2)?,"grant_present":r.get::<_,bool>(3)?})))?.collect::<rusqlite::Result<Vec<_>>>()?;
|
|
let counts=json!({"events":db.query_row("SELECT count(*) FROM events",[],|r|r.get::<_,u64>(0))?,"job_events":db.query_row("SELECT count(*) FROM job_events",[],|r|r.get::<_,u64>(0))?,
|
|
"agent_consumed":consumed.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"agent_execution_evidence":consumed.query_row("SELECT count(*) FROM execution_evidence",[],|r|r.get::<_,u64>(0))?,
|
|
"helper_consumed":helper.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0))?,"helper_intents":intents.query_row("SELECT count(*) FROM system_intents",[],|r|r.get::<_,u64>(0))?});
|
|
Ok(json!({"agent":agent,"helper":helper_meta,"jobs":jobs,"counts":counts}))
|
|
}
|
|
pub fn run() -> Result<()> {
|
|
let args=std::env::args().skip(1).collect::<Vec<_>>();
|
|
let read_only=args==["--read-idle-check"];
|
|
ensure!(read_only || args==["--stop-known-idle-agent"],"QUIESCENT_ARGUMENTS");
|
|
admin()?;
|
|
let bootstrap = PinnedFile::open(
|
|
Path::new(r"C:\ProgramData\RustDiscoveryBootstrap"),
|
|
true,
|
|
&[],
|
|
&[],
|
|
false,
|
|
)?;
|
|
let dir = bootstrap.path.join(format!("quiescent-stop-{CASE}"));
|
|
let mut dir_guard=if read_only {None}else{
|
|
std::fs::create_dir(&dir)?;
|
|
Some(PinnedFile::open(&dir,true,&[],&[],false)?)
|
|
};
|
|
let readers = [
|
|
ipc::service_sid(rmm_agent_windows::SERVICE_NAME)?,
|
|
ipc::service_sid(ipc::HELPER_SERVICE)?,
|
|
];
|
|
let (mut pin_guard, raw) = protected(
|
|
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-pin.json"),
|
|
&readers,
|
|
PIN,
|
|
)?;
|
|
let pin: ipc::Pin = serde_json::from_slice(&raw)?;
|
|
pin.validate()?;
|
|
ensure!(
|
|
pin.agent.binary_sha256 == AGENT && pin.helper.binary_sha256 == HELPER,
|
|
"QUIESCENT_EXACT_PAIR"
|
|
);
|
|
let (mut settings_guard, _) = protected(
|
|
Path::new(r"C:\ProgramData\RustDiscoverySystem\helper.json"),
|
|
&readers,
|
|
SETTINGS,
|
|
)?;
|
|
let (mut config_guard, raw) = protected(
|
|
Path::new(r"C:\ProgramData\RustDiscovery\config.json"),
|
|
&[readers[0].clone()],
|
|
CONFIG,
|
|
)?;
|
|
let cfg: serde_json::Value = serde_json::from_slice(&raw)?;
|
|
ensure!(
|
|
cfg["enable_jobs"] == true
|
|
&& cfg.get("windows_echo_probe_only").is_none_or(|v|v==false)
|
|
&& cfg["state_directory"] == AGENT_STATE,
|
|
"QUIESCENT_EXACT_CONFIGURATION"
|
|
);
|
|
let agent_service = service(!read_only)?;
|
|
let before = status(&agent_service)?;
|
|
ensure!(
|
|
before.dwCurrentState == SERVICE_RUNNING,
|
|
"QUIESCENT_AGENT_NOT_RUNNING"
|
|
);
|
|
let mut peer = PeerProof::for_service(&pin.agent, before.dwProcessId)?;
|
|
let helper_manager=Handle(unsafe{OpenSCManagerW(ptr::null(),ptr::null(),SC_MANAGER_CONNECT)});
|
|
ensure!(!helper_manager.0.is_null(),"QUIESCENT_HELPER_SCM_MANAGER");
|
|
let helper_service=Handle(unsafe{OpenServiceW(helper_manager.0,ipc::wide(ipc::HELPER_SERVICE).as_ptr(),SERVICE_QUERY_STATUS|SERVICE_QUERY_CONFIG)});
|
|
ensure!(!helper_service.0.is_null(),"QUIESCENT_HELPER_SCM");
|
|
let helper_before=status(&helper_service)?;
|
|
ensure!(helper_before.dwCurrentState==SERVICE_RUNNING,"QUIESCENT_HELPER_NOT_RUNNING");
|
|
let mut helper_peer=PeerProof::for_service(&pin.helper,helper_before.dwProcessId)?;
|
|
// Keep original journal/sidecar names and ledger against replacement.
|
|
let journal_path = Path::new(AGENT_STATE).join("telemetry.sqlite");
|
|
let journal_file = hold_agent(&journal_path)?;
|
|
let _wal = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-wal"))?;
|
|
let _shm = hold_agent(&Path::new(AGENT_STATE).join("telemetry.sqlite-shm"))?;
|
|
let consumption_path = Path::new(AGENT_STATE).join("consumption.sqlite");
|
|
let consumption_file = hold_agent(&consumption_path)?;
|
|
let helper_writer = ipc::service_sid(ipc::HELPER_SERVICE)?;
|
|
let mut helper_file = PinnedFile::open_read_shared(
|
|
&Path::new(HELPER_STATE).join("ledger.sqlite"),
|
|
false,
|
|
&[],
|
|
std::slice::from_ref(&helper_writer),
|
|
)?;
|
|
let mut intent_file = PinnedFile::open_read_shared(
|
|
Path::new(r"C:\ProgramData\RustDiscoverySystem\agent-intents\system-intents.sqlite"),
|
|
false,
|
|
&[],
|
|
&[readers[0].clone()],
|
|
)?;
|
|
let db = Connection::open_with_flags(&journal_path, if read_only {OpenFlags::SQLITE_OPEN_READ_ONLY}else{OpenFlags::SQLITE_OPEN_READ_WRITE})?;
|
|
db.busy_timeout(Duration::from_millis(20))?;
|
|
let consumed =
|
|
Connection::open_with_flags(&consumption_path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
|
|
let helper =
|
|
Connection::open_with_flags(&helper_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
|
|
let intents =
|
|
Connection::open_with_flags(&intent_file.path, OpenFlags::SQLITE_OPEN_READ_ONLY)?;
|
|
if read_only {
|
|
let mut observations=Vec::new();
|
|
for _ in 0..10 {
|
|
db.execute_batch("BEGIN")?;helper.execute_batch("BEGIN")?;
|
|
let checked=idle(&db,&consumed,&helper,&intents,&pin.binding);
|
|
let metadata=safe_metadata(&db,&consumed,&helper,&intents)?;
|
|
let error=checked.as_ref().err().map(safe_error);
|
|
helper.execute_batch("ROLLBACK")?;db.execute_batch("ROLLBACK")?;
|
|
observations.push(json!({"observed_at":chrono::Utc::now(),"idle_check_passed":checked.is_ok(),"error":error,"metadata":metadata}));
|
|
std::thread::sleep(Duration::from_millis(100));
|
|
}
|
|
peer.check()?;helper_peer.check()?;
|
|
println!("{}",serde_json::to_string(&json!({"schema_version":1,"mode":"read_idle_check","read_only":true,"quiescence_reservation_held":false,"stop_requested":false,"case_created":false,"sql_data_changed":false,"samples":observations}))?);
|
|
return Ok(());
|
|
}
|
|
let until = Instant::now() + Duration::from_secs(30);
|
|
let locked = loop {
|
|
if Instant::now() >= until {
|
|
anyhow::bail!("QUIESCENT_HEAD_NOT_OBSERVED_NO_STOP");
|
|
}
|
|
if db.execute_batch("BEGIN IMMEDIATE").is_err() {
|
|
std::thread::sleep(Duration::from_millis(25));
|
|
continue;
|
|
}
|
|
helper.execute_batch("BEGIN")?;
|
|
let value = idle(&db, &consumed, &helper, &intents, &pin.binding);
|
|
helper.execute_batch("ROLLBACK")?;
|
|
match value {
|
|
Ok(value) => break value,
|
|
Err(_) => {
|
|
db.execute_batch("ROLLBACK")?;
|
|
std::thread::sleep(Duration::from_millis(25));
|
|
}
|
|
}
|
|
};
|
|
// All final observations occur while new agent writes remain excluded.
|
|
peer.check()?;
|
|
helper_peer.check()?;
|
|
pin_guard.check()?;
|
|
settings_guard.check()?;
|
|
config_guard.check()?;
|
|
dir_guard.as_mut().context("QUIESCENT_CASE_GUARD")?.check()?;
|
|
check_id(&journal_file, &journal_path)?;
|
|
check_id(&consumption_file, &consumption_path)?;
|
|
helper_file.check()?;
|
|
intent_file.check()?;
|
|
let current = status(&agent_service)?;
|
|
ensure!(
|
|
current.dwCurrentState == SERVICE_RUNNING && current.dwProcessId == before.dwProcessId,
|
|
"QUIESCENT_ORIGINAL_PROCESS_CHANGED"
|
|
);
|
|
receipt(
|
|
&dir,
|
|
"stop-intent.json",
|
|
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"agent_sha256":AGENT,"helper_sha256":HELPER,"pin_sha256":PIN,"config_sha256":CONFIG,
|
|
"agent_pid":before.dwProcessId,"journal_file_id":ipc::file_identity(&journal_file)?,"consumption_file_id":ipc::file_identity(&consumption_file)?,"helper_ledger_file_id":helper_file.identity,"decision_id":locked.decision,
|
|
"checkpoint":locked.checkpoint,"helper_applied_checkpoint":locked.helper_checkpoint,"signed_request_sha256":locked.request_sha256,"signed_helper_response_sha256":locked.response_sha256,"original_echo_job":locked.original_echo_job,
|
|
"pending_job":JOB,"pending_control_request":locked.pending_request,"pending_control_request_sha256":locked.pending_request_sha256,"new_grants":0,"helper_consumptions":0,"helper_intents":0,"sql_data_changed":false,"agent_journal_immediate_reservation_held":true,"stop_service_only":rmm_agent_windows::SERVICE_NAME,"force_kill":false}),
|
|
)?;
|
|
let mut returned: SERVICE_STATUS = unsafe { zeroed() };
|
|
let stop_ok =
|
|
unsafe { ControlService(agent_service.0, SERVICE_CONTROL_STOP, &mut returned) } != 0;
|
|
let error = if stop_ok {
|
|
None
|
|
} else {
|
|
Some(unsafe { GetLastError() })
|
|
};
|
|
let wait = Instant::now() + Duration::from_secs(125);
|
|
let mut final_status = status(&agent_service)?;
|
|
while stop_ok && final_status.dwCurrentState != SERVICE_STOPPED && Instant::now() < wait {
|
|
std::thread::sleep(Duration::from_millis(50));
|
|
final_status = status(&agent_service)?;
|
|
}
|
|
let stopped = stop_ok && final_status.dwCurrentState == SERVICE_STOPPED;
|
|
helper_peer.check()?;
|
|
// Still held through the confirmed stop (or bounded honest failure).
|
|
check_id(&journal_file, &journal_path)?;
|
|
check_id(&consumption_file, &consumption_path)?;
|
|
receipt(
|
|
&dir,
|
|
"stop-result.json",
|
|
&json!({"schema_version":1,"case_id":CASE,"observed_at":chrono::Utc::now(),"normal_stop_requested_once":stop_ok,"native_error":error,"stopped":stopped,"state":final_status.dwCurrentState,"pid":final_status.dwProcessId,
|
|
"sql_data_changed":false,"job_executed":false,"helper_stopped":false,"reset":false,"force_kill":false,"reservation_held_until_observation":true}),
|
|
)?;
|
|
db.execute_batch("ROLLBACK")?;
|
|
ensure!(stopped, "QUIESCENT_STOP_UNCONFIRMED_NO_FORCE");
|
|
println!("{{\"case_id\":\"{CASE}\",\"stopped\":true,\"sql_data_changed\":false}}");
|
|
Ok(())
|
|
}
|
|
}
|
|
#[cfg(all(windows, feature = "system-helper"))]
|
|
fn main() {
|
|
if let Err(error) = platform::run() {
|
|
eprintln!("{}", error);
|
|
std::process::exit(1);
|
|
}
|
|
}
|
|
#[cfg(not(all(windows, feature = "system-helper")))]
|
|
fn main() {
|
|
eprintln!("Windows SYSTEM-helper SDK bootstrap only");
|
|
std::process::exit(1);
|
|
}
|