File homeassistant-os-agent-1.6.0.obscpio of Package homeassistant-os-agent

Overview Repositories Revisions Requests Users Attributes Meta

File homeassistant-os-agent-1.6.0.obscpio of Package homeassistant-os-agent (Revision 01cd765a993ca24270571eb6ad56087e)

Currently displaying revision 01cd765a993ca24270571eb6ad56087e , Show latest

07070100000000000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002B00000000homeassistant-os-agent-1.6.0/.devcontainer07070100000001000081A400000000000000000000000164F6FC38000003DD000000000000000000000000000000000000003600000000homeassistant-os-agent-1.6.0/.devcontainer/Dockerfile# [Choice] Go version: 1, 1.15, 1.14
ARG VARIANT=1-bookworm
FROM mcr.microsoft.com/vscode/devcontainers/go:${VARIANT}

# [Option] Install Node.js
ARG NODE_VERSION="lts/*"
RUN if [ "${NODE_VERSION}" != "none" ]; then su vscode -c "umask 0002 && . /usr/local/share/nvm/nvm.sh && nvm install ${NODE_VERSION} 2>&1"; fi

# [Optional] Uncomment this section to install additional OS packages.
RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
    && apt-get -y install --no-install-recommends \
        dbus \
        libglib2.0-bin \
        apparmor-utils \
    && rm -rf /var/lib/apt/lists/*

# [Optional] Uncomment the next line to use go get to install anything else you need
# RUN go get -x github.com/coreos/go-systemd/daemon
# RUN go get -x github.com/fntlnz/mountinfo
# RUN go get -x github.com/godbus/dbus

# [Optional] Uncomment this line to install global node packages.
# RUN su vscode -c "source /usr/local/share/nvm/nvm.sh && npm install -g <your-package-here>" 2>&1
07070100000002000081ED00000000000000000000000164F6FC3800000197000000000000000000000000000000000000003300000000homeassistant-os-agent-1.6.0/.devcontainer/dbus.sh#!/bin/bash
set -ex

function init_dbus() {
    if pgrep dbus-daemon; then
        echo "Dbus is running"
        return 0
    fi

echo "Startup dbus"
    mkdir -p /var/lib/dbus
    cp -f /etc/machine-id /var/lib/dbus/machine-id

# cleanups
    mkdir -p /run/dbus
    rm -f /run/dbus/pid

# run
    dbus-daemon --system --print-address
}

init_dbus
cp contrib/io.hass.conf /etc/dbus-1/system.d/
07070100000003000081A400000000000000000000000164F6FC38000002AD000000000000000000000000000000000000003D00000000homeassistant-os-agent-1.6.0/.devcontainer/devcontainer.json{
	"name": "Go Home Assistant OS Agent",
	"build": {
		"dockerfile": "Dockerfile",
		"args": {
			"VARIANT": "1.19-bullseye",
			"NODE_VERSION": "none"
		}
	},
	"postCreateCommand": "go mod download",
	"runArgs": [ "--cap-add=SYS_PTRACE", "--security-opt", "seccomp=unconfined" ],
	//"mounts" : [ "source=/run/dbus,target=/run/dbus,type=bind" ],
	"settings": { 
		"terminal.integrated.shell.linux": "/bin/bash",
		"go.useGoProxyToCheckForToolUpdates": false,
		"go.useLanguageServer": true,
		"go.gopath": "/go",
		"go.goroot": "/usr/local/go",
		"go.toolsGopath": "/go/bin",
		"go.lintTool":"golangci-lint",
		"go.lintFlags": [
			"--fast"
		]
	},
	"extensions": [
		"golang.Go"
	]
}
07070100000004000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002500000000homeassistant-os-agent-1.6.0/.github07070100000005000081A400000000000000000000000164F6FC380000011B000000000000000000000000000000000000003400000000homeassistant-os-agent-1.6.0/.github/dependabot.ymlversion: 2
updates:

- package-ecosystem: gomod
  directory: "/"
  schedule:
    interval: daily
    time: "06:00"
  open-pull-requests-limit: 10

- package-ecosystem: "github-actions"
  directory: "/"
  schedule:
    interval: daily
    time: "06:00"
  open-pull-requests-limit: 10
07070100000006000081A400000000000000000000000164F6FC3800000095000000000000000000000000000000000000003900000000homeassistant-os-agent-1.6.0/.github/release-drafter.ymlname-template: '$RESOLVED_VERSION'
tag-template: '$RESOLVED_VERSION'
version-resolver:
  default: minor
template: |
  ## What's Changed
  
  $CHANGES07070100000007000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002F00000000homeassistant-os-agent-1.6.0/.github/workflows07070100000008000081A400000000000000000000000164F6FC38000003A0000000000000000000000000000000000000003900000000homeassistant-os-agent-1.6.0/.github/workflows/build.ymlname: build

on:
  release:
    types: ["published"]
  pull_request:
    branches: ["main"]

env:
  GOLANG_VERSION: "1.20"

jobs:
  build:
    name: Build OS-Agent
    runs-on: ubuntu-latest
    steps:
      - name: Checkout the repository
        uses: actions/checkout@v4.0.0
        with:
          fetch-depth: 0 # Needed for changelog generation

- name: Setup go ${{ env.GOLANG_VERSION }}
        uses: actions/setup-go@v4
        with:
          go-version: ${{ env.GOLANG_VERSION }}

- name: Run GoReleaser build
        uses: goreleaser/goreleaser-action@v4.4.0
        if: github.event_name == 'pull_request'
        with:
          args: build --snapshot --clean

- name: Run GoReleaser release
        uses: goreleaser/goreleaser-action@v4.4.0
        if: github.event_name == 'release'
        with:
          args: release --clean
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
07070100000009000081A400000000000000000000000164F6FC380000012F000000000000000000000000000000000000004100000000homeassistant-os-agent-1.6.0/.github/workflows/golangci-lint.ymlname: golangci-lint
on:
  push:
    branches:
      - main
  pull_request:
jobs:
  golangci:
    name: lint
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4.0.0
      - name: golangci-lint
        uses: golangci/golangci-lint-action@v3.7.0
        with:
          version: latest
0707010000000A000081A400000000000000000000000164F6FC3800000138000000000000000000000000000000000000004300000000homeassistant-os-agent-1.6.0/.github/workflows/release-drafter.ymlname: Release Drafter

on:
  push:
    # branches to consider in the event; optional, defaults to all
    branches:
      - main

jobs:
  update_release_draft:
    runs-on: ubuntu-latest
    steps:
      - uses: release-drafter/release-drafter@v5
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
0707010000000B000081A400000000000000000000000164F6FC3800000006000000000000000000000000000000000000002800000000homeassistant-os-agent-1.6.0/.gitignoredist/
0707010000000C000081A400000000000000000000000164F6FC3800000056000000000000000000000000000000000000002C00000000homeassistant-os-agent-1.6.0/.golangci.yamllinters:
  presets:
    - bugs
  enable:
    - gosimple
    - ineffassign
    - unused0707010000000D000081A400000000000000000000000164F6FC380000058F000000000000000000000000000000000000002D00000000homeassistant-os-agent-1.6.0/.goreleaser.ymlproject_name: os-agent
before:
  hooks:
    - go mod tidy
    - go generate ./...
builds:
  - env:
      - CGO_ENABLED=0
    binary: os-agent
    ldflags:
      - -s -w
      - -X main.version={{.Version}}
      - -X main.board=Supervised
    goos:
      - linux
    goarch:
      - 386
      - amd64
      - arm
      - arm64
    goarm:
      - 5
      - 6
      - 7

checksum:
  name_template: checksums.txt
  algorithm: sha512

changelog:
  sort: asc

nfpms:
  - maintainer: Home Assistant <hello@home-assistant.io>
    description: Home Assistant OS Agent
    homepage: https://www.home-assistant.io
    license: Apache 2.0
    section: default
    priority: extra
    bindir: /usr/bin
    formats:
      - deb
    dependencies:
      - udisks2
    file_name_template: >-
      {{ .PackageName }}_{{ .Version }}_{{ .Os }}_
      {{- if eq .Arch "amd64" }}x86_64
      {{- else if eq .Arch "386" }}i386
      {{- else if eq .Arch "arm64" }}aarch64
      {{- else }}{{ .Arch }}{{ with .Arm }}v{{ . }}{{ end }}
      {{ with .Mips }}_{{ . }}{{ end }}
      {{ end }}
    contents:
      - src: contrib/haos-agent.service
        dst: /usr/lib/systemd/system/haos-agent.service
      - src: contrib/io.hass.conf
        dst: /etc/dbus-1/system.d/io.hass.conf
    scripts:
      postinstall: contrib/debian/postinstall.sh
      preremove: contrib/debian/preremove.sh
      postremove: contrib/debian/postremove.sh

release:
0707010000000E000081A400000000000000000000000164F6FC3800002C4E000000000000000000000000000000000000002500000000homeassistant-os-agent-1.6.0/LICENSE                                 Apache License
                           Version 2.0, January 2004
                        http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
      and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such entity, whether by contract or
      otherwise, or (ii) ownership of fifty percent (50%) or more of the
      outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
      exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
      including but not limited to software source code, documentation
      source, and configuration files.

"Object" form shall mean any form resulting from mechanical
      transformation or translation of a Source form, including but
      not limited to compiled object code, generated documentation,
      and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
      Object form, made available under the License, as indicated by a
      copyright notice that is included in or attached to the work
      (an example is provided in the Appendix below).

"Derivative Works" shall mean any work, whether in Source or Object
      form, that is based on (or derived from) the Work and for which the
      editorial revisions, annotations, elaborations, or other modifications
      represent, as a whole, an original work of authorship. For the purposes
      of this License, Derivative Works shall not include works that remain
      separable from, or merely link (or bind by name) to the interfaces of,
      the Work and Derivative Works thereof.

"Contribution" shall mean any work of authorship, including
      the original version of the Work and any modifications or additions
      to that Work or Derivative Works thereof, that is intentionally
      submitted to Licensor for inclusion in the Work by the copyright owner
      or by an individual or Legal Entity authorized to submit on behalf of
      the copyright owner. For the purposes of this definition, "submitted"
      means any form of electronic, verbal, or written communication sent
      to the Licensor or its representatives, including but not limited to
      communication on electronic mailing lists, source code control systems,
      and issue tracking systems that are managed by, or on behalf of, the
      Licensor for the purpose of discussing and improving the Work, but
      excluding communication that is conspicuously marked or otherwise
      designated in writing by the copyright owner as "Not a Contribution."

"Contributor" shall mean Licensor and any individual or Legal Entity
      on behalf of whom a Contribution has been received by Licensor and
      subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      copyright license to reproduce, prepare Derivative Works of,
      publicly display, publicly perform, sublicense, and distribute the
      Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
      this License, each Contributor hereby grants to You a perpetual,
      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
      (except as stated in this section) patent license to make, have made,
      use, offer to sell, sell, import, and otherwise transfer the Work,
      where such license applies only to those patent claims licensable
      by such Contributor that are necessarily infringed by their
      Contribution(s) alone or by combination of their Contribution(s)
      with the Work to which such Contribution(s) was submitted. If You
      institute patent litigation against any entity (including a
      cross-claim or counterclaim in a lawsuit) alleging that the Work
      or a Contribution incorporated within the Work constitutes direct
      or contributory patent infringement, then any patent licenses
      granted to You under this License for that Work shall terminate
      as of the date such litigation is filed.

4. Redistribution. You may reproduce and distribute copies of the
      Work or Derivative Works thereof in any medium, with or without
      modifications, and in Source or Object form, provided that You
      meet the following conditions:

(a) You must give any other recipients of the Work or
          Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
          stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
          that You distribute, all copyright, patent, trademark, and
          attribution notices from the Source form of the Work,
          excluding those notices that do not pertain to any part of
          the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
          distribution, then any Derivative Works that You distribute must
          include a readable copy of the attribution notices contained
          within such NOTICE file, excluding those notices that do not
          pertain to any part of the Derivative Works, in at least one
          of the following places: within a NOTICE text file distributed
          as part of the Derivative Works; within the Source form or
          documentation, if provided along with the Derivative Works; or,
          within a display generated by the Derivative Works, if and
          wherever such third-party notices normally appear. The contents
          of the NOTICE file are for informational purposes only and
          do not modify the License. You may add Your own attribution
          notices within Derivative Works that You distribute, alongside
          or as an addendum to the NOTICE text from the Work, provided
          that such additional attribution notices cannot be construed
          as modifying the License.

You may add Your own copyright statement to Your modifications and
      may provide additional or different license terms and conditions
      for use, reproduction, or distribution of Your modifications, or
      for any such Derivative Works as a whole, provided Your use,
      reproduction, and distribution of the Work otherwise complies with
      the conditions stated in this License.

5. Submission of Contributions. Unless You explicitly state otherwise,
      any Contribution intentionally submitted for inclusion in the Work
      by You to the Licensor shall be under the terms and conditions of
      this License, without any additional terms or conditions.
      Notwithstanding the above, nothing herein shall supersede or modify
      the terms of any separate license agreement you may have executed
      with Licensor regarding such Contributions.

6. Trademarks. This License does not grant permission to use the trade
      names, trademarks, service marks, or product names of the Licensor,
      except as required for reasonable and customary use in describing the
      origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
      agreed to in writing, Licensor provides the Work (and each
      Contributor provides its Contributions) on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
      implied, including, without limitation, any warranties or conditions
      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
      PARTICULAR PURPOSE. You are solely responsible for determining the
      appropriateness of using or redistributing the Work and assume any
      risks associated with Your exercise of permissions under this License.

8. Limitation of Liability. In no event and under no legal theory,
      whether in tort (including negligence), contract, or otherwise,
      unless required by applicable law (such as deliberate and grossly
      negligent acts) or agreed to in writing, shall any Contributor be
      liable to You for damages, including any direct, indirect, special,
      incidental, or consequential damages of any character arising as a
      result of this License or out of the use or inability to use the
      Work (including but not limited to damages for loss of goodwill,
      work stoppage, computer failure or malfunction, or any and all
      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,
      defend, and hold each Contributor harmless for any liability
      incurred by, or claims asserted against, such Contributor by reason
      of your accepting any such warranty or additional liability.

END OF TERMS AND CONDITIONS

APPENDIX: How to apply the Apache License to your work.

To apply the Apache License to your work, attach the following
      boilerplate notice, with the fields enclosed by brackets "[]"
      replaced with your own identifying information. (Don't include
      the brackets!)  The text should be enclosed in the appropriate
      comment syntax for the file format. We also recommend that a
      file or class name and description of purpose be included on the
      same "printed page" as the copyright notice for easier
      identification within third-party archives.

Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
0707010000000F000081A400000000000000000000000164F6FC38000006EA000000000000000000000000000000000000002700000000homeassistant-os-agent-1.6.0/README.md# Agent for Home Assistant OS

This is the OS Agent for Home Assistant. It is used for Home Assistant
OS and Home Assistant Supervised installation types and it allows the
Home Assistant Supervisor to communicate with the host operating system.

## Installation & Update

### Using the Home Assistant Operating System

The OS Agent is pre-installed with the Home Assistant Operating System.

Updates are part of the Home Assistant Operating System updates, which
the Home Assistant UI will offer to upgrade to when there is a new version
available.

### Using Home Assistant Supervised on Debian

Download the latest Debian package from OS Agent GitHub release page at:

<https://github.com/home-assistant/os-agent/releases/latest>

Next, install (or update) the downloaded Debian package using:

```shell
sudo dpkg -i os-agent_1.0.0_linux_x86_64.deb
```

Note: Replace the `deb` file in the above example with the file you
have downloaded from the releases page.

You can test if the installation was successful by running:

```bash
gdbus introspect --system --dest io.hass.os --object-path /io/hass/os
```

This should **not** return an error. If you get an object introspection
with `interface` etc. OS Agent is working as expected.

You might need to install `libglib2.0-bin` to get the `gdbus` command.

## Uninstall

To remove OS Agent from your system use the Debian packaging system:

```shell
sudo dpkg -r os-agent
```

## Development

### Compile

```shell
go build -ldflags "-X main.version="
```

### Tests

```shell
gdbus introspect --system --dest io.hass.os --object-path /io/hass/os
gdbus call --system --dest io.hass.os --object-path /io/hass/os/Boards/Yellow --method org.freedesktop.DBus.Properties.Set io.hass.os.Boards.Yellow PowerLED "<false>"
```
07070100000010000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002600000000homeassistant-os-agent-1.6.0/apparmor07070100000011000081A400000000000000000000000164F6FC3800000B1E000000000000000000000000000000000000003200000000homeassistant-os-agent-1.6.0/apparmor/apparmor.gopackage apparmor

import (
	"fmt"
	"os/exec"
	"regexp"

"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath        = "/io/hass/os/AppArmor"
	ifaceName         = "io.hass.os.AppArmor"
	appArmorParserCmd = "apparmor_parser"
)

type apparmor struct {
	conn  *dbus.Conn
	props *prop.Properties
}

func getAppArmorVersion() string {
	cmd := exec.Command(appArmorParserCmd, "--version")

out, err := cmd.CombinedOutput()
	if err != nil {
		logging.Warning.Print(err)
		return string("")
	}

re := regexp.MustCompile("version ([0-9.]*)")
	found := re.FindSubmatch(out)
	if len(found) < 1 {
		logging.Error.Fatalln("Can't read version from parser!")
	}

return string(found[1])
}

func (d apparmor) LoadProfile(profilePath string, cachePath string) (bool, *dbus.Error) {
	logging.Info.Printf("Load AppArmor profile '%s'.", profilePath)

cmd := exec.Command(appArmorParserCmd, "--replace", "--write-cache", "--cache-loc", cachePath, profilePath)
	out, err := cmd.CombinedOutput()
	if err != nil {
		return false, dbus.MakeFailedError(fmt.Errorf("Can't load profile '%s': %w", profilePath, err))
	}

logging.Info.Printf("Load profile '%s': %s", profilePath, out)
	return true, nil
}

func (d apparmor) UnloadProfile(profilePath string, cachePath string) (bool, *dbus.Error) {
	logging.Info.Printf("Unload AppArmor profile '%s'.", profilePath)

cmd := exec.Command(appArmorParserCmd, "--remove", "--write-cache", "--cache-loc", cachePath, profilePath)

out, err := cmd.CombinedOutput()
	if err != nil {
		return false, dbus.MakeFailedError(fmt.Errorf("Can't unload profile '%s': %w", profilePath, err))
	}

logging.Info.Printf("Unload profile '%s': %s", profilePath, out)
	return true, nil
}

func InitializeDBus(conn *dbus.Conn) {
	d := apparmor{
		conn: conn,
	}

propsSpec := map[string]map[string]*prop.Prop{
		ifaceName: {
			"ParserVersion": {
				Value:    getAppArmorVersion(),
				Writable: false,
				Emit:     prop.EmitInvalidates,
				Callback: nil,
			},
		},
	}

props, err := prop.Export(conn, objectPath, propsSpec)
	if err != nil {
		logging.Critical.Panic(err)
	}
	d.props = props

err = conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

node := &introspect.Node{
		Name: objectPath,
		Interfaces: []introspect.Interface{
			introspect.IntrospectData,
			prop.IntrospectData,
			{
				Name:       ifaceName,
				Methods:    introspect.Methods(d),
				Properties: props.Introspection(ifaceName),
			},
		},
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
07070100000012000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002400000000homeassistant-os-agent-1.6.0/boards07070100000013000081A400000000000000000000000164F6FC3800000702000000000000000000000000000000000000002E00000000homeassistant-os-agent-1.6.0/boards/boards.gopackage boards

import (
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

"github.com/home-assistant/os-agent/boards/green"
	"github.com/home-assistant/os-agent/boards/supervised"
	"github.com/home-assistant/os-agent/boards/yellow"
	logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath = "/io/hass/os/Boards"
	ifaceName  = "io.hass.os.Boards"
)

type boards struct {
	conn  *dbus.Conn
	props *prop.Properties
}

func InitializeDBus(conn *dbus.Conn, board string) {
	d := boards{
		conn: conn,
	}

propsSpec := map[string]map[string]*prop.Prop{
		ifaceName: {
			"Board": {
				Value:    board,
				Writable: false,
				Emit:     prop.EmitInvalidates,
				Callback: nil,
			},
		},
	}

props, err := prop.Export(conn, objectPath, propsSpec)
	if err != nil {
		logging.Critical.Panic(err)
	}
	d.props = props

err = conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)

// Initialize the board
	if board == "Yellow" {
		yellow.InitializeDBus(conn)
	} else if board == "Green" {
		green.InitializeDBus(conn)
	} else if board == "Supervised" {
		supervised.InitializeDBus(conn)
	} else {
		logging.Info.Printf("No specific Board features for %s", board)
	}
}
07070100000014000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002A00000000homeassistant-os-agent-1.6.0/boards/green07070100000015000081A400000000000000000000000164F6FC3800000A84000000000000000000000000000000000000003300000000homeassistant-os-agent-1.6.0/boards/green/green.gopackage green

import (
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

"github.com/home-assistant/os-agent/utils/led"
	logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath = "/io/hass/os/Boards/Green"
	ifaceName  = "io.hass.os.Boards.Green"
)

var (
	ledPower    led.LED = led.LED{Name: "power", DefaultTrigger: "default-on"}
	ledActivity led.LED = led.LED{Name: "activity", DefaultTrigger: "activity"}
	ledUser     led.LED = led.LED{Name: "user", DefaultTrigger: "heartbeat"}
)

type green struct {
	conn  *dbus.Conn
	props *prop.Properties
}

func getTriggerLED(led led.LED) bool {
	value, err := led.GetTrigger()
	if err != nil {
		logging.Error.Print(err)
	}
	return value != "none"
}

func setTriggerLED(led led.LED, c *prop.Change) *dbus.Error {
	logging.Info.Printf("Set Green %s LED to %t", led.Name, c.Value)
	err := led.SetTrigger(c.Value.(bool))
	if err != nil {
		return dbus.MakeFailedError(err)
	}
	return nil
}

func setPowerLED(c *prop.Change) *dbus.Error {
	return setTriggerLED(ledPower, c)
}

func setActivityLED(c *prop.Change) *dbus.Error {
	return setTriggerLED(ledActivity, c)
}

func setUserLED(c *prop.Change) *dbus.Error {
	return setTriggerLED(ledUser, c)
}

func InitializeDBus(conn *dbus.Conn) {
	d := green{
		conn: conn,
	}

// Init base value
	ledPowerValue := getTriggerLED(ledPower)
	ledActivityValue := getTriggerLED(ledActivity)
	ledUserValue := getTriggerLED(ledUser)

propsSpec := map[string]map[string]*prop.Prop{
		ifaceName: {
			"PowerLED": {
				Value:    ledPowerValue,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: setPowerLED,
			},
			"ActivityLED": {
				Value:    ledActivityValue,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: setActivityLED,
			},
			"UserLED": {
				Value:    ledUserValue,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: setUserLED,
			},
		},
	}

props, err := prop.Export(conn, objectPath, propsSpec)
	if err != nil {
		logging.Critical.Panic(err)
	}
	d.props = props

err = conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
07070100000016000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002F00000000homeassistant-os-agent-1.6.0/boards/supervised07070100000017000081A400000000000000000000000164F6FC38000003D1000000000000000000000000000000000000003D00000000homeassistant-os-agent-1.6.0/boards/supervised/supervised.gopackage supervised

import (
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath = "/io/hass/os/Boards/Supervised"
	ifaceName  = "io.hass.os.Boards.Supervised"
)

type supervised struct {
	conn *dbus.Conn
}

func InitializeDBus(conn *dbus.Conn) {
	d := supervised{
		conn: conn,
	}

err := conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

node := &introspect.Node{
		Name: objectPath,
		Interfaces: []introspect.Interface{
			introspect.IntrospectData,
			prop.IntrospectData,
			{
				Name:    ifaceName,
				Methods: introspect.Methods(d),
			},
		},
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
07070100000018000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002B00000000homeassistant-os-agent-1.6.0/boards/yellow07070100000019000081A400000000000000000000000164F6FC3800000DEE000000000000000000000000000000000000003500000000homeassistant-os-agent-1.6.0/boards/yellow/yellow.gopackage yellow

import (
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

"github.com/home-assistant/os-agent/utils/bootfile"
	logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath = "/io/hass/os/Boards/Yellow"
	ifaceName  = "io.hass.os.Boards.Yellow"
	bootConfig = "/mnt/boot/config.txt"
)

var (
	optLEDPower     bool
	optLEDDisk      bool
	optLEDHeartbeat bool
	bootFile        = bootfile.Editor{FilePath: bootConfig, Delimiter: "="}
)

type yellow struct {
	conn  *dbus.Conn
	props *prop.Properties
}

func getStatusLEDPower() bool {
	value, _ := bootFile.ReadOption("dtparam=pwr_led_trigger", "default-on")
	return value != "none"
}

func getStatusLEDDisk() bool {
	value, _ := bootFile.ReadOption("dtparam=act_led_trigger", "activity")
	return value != "none"
}

func getStatusLEDHeartbeat() bool {
	value, _ := bootFile.ReadOption("dtparam=usr_led_trigger", "heartbeat")
	return value != "none"
}

func setStatusLEDPower(c *prop.Change) *dbus.Error {
	logging.Info.Printf("Set Yellow Power LED to %t", c.Value)
	optLEDPower = c.Value.(bool)

var err error
	if c.Value.(bool) {
		err = bootFile.DisableOption("dtparam=pwr_led_trigger")
	} else {
		err = bootFile.SetOption("dtparam=pwr_led_trigger", "none")
	}

if err != nil {
		return dbus.MakeFailedError(err)
	}
	return nil
}

func setStatusLEDDisk(c *prop.Change) *dbus.Error {
	logging.Info.Printf("Set Yellow Disk LED to %t", c.Value)
	optLEDDisk = c.Value.(bool)

var err error
	if c.Value.(bool) {
		err = bootFile.DisableOption("dtparam=act_led_trigger")
	} else {
		err = bootFile.SetOption("dtparam=act_led_trigger", "none")
	}

if err != nil {
		return dbus.MakeFailedError(err)
	}
	return nil
}

func setStatusLEDHeartbeat(c *prop.Change) *dbus.Error {
	logging.Info.Printf("Set Yellow Heartbeat LED to %t", c.Value)
	optLEDHeartbeat = c.Value.(bool)

var err error
	if c.Value.(bool) {
		err = bootFile.DisableOption("dtparam=usr_led_trigger")
	} else {
		err = bootFile.SetOption("dtparam=usr_led_trigger", "none")
	}

if err != nil {
		return dbus.MakeFailedError(err)
	}
	return nil
}

func InitializeDBus(conn *dbus.Conn) {
	d := yellow{
		conn: conn,
	}

// Init base value
	optLEDPower = getStatusLEDPower()
	optLEDDisk = getStatusLEDDisk()
	optLEDHeartbeat = getStatusLEDHeartbeat()

propsSpec := map[string]map[string]*prop.Prop{
		ifaceName: {
			"PowerLED": {
				Value:    optLEDPower,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: setStatusLEDPower,
			},
			"DiskLED": {
				Value:    optLEDDisk,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: setStatusLEDDisk,
			},
			"HeartbeatLED": {
				Value:    optLEDHeartbeat,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: setStatusLEDHeartbeat,
			},
		},
	}

props, err := prop.Export(conn, objectPath, propsSpec)
	if err != nil {
		logging.Critical.Panic(err)
	}
	d.props = props

err = conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
0707010000001A000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002400000000homeassistant-os-agent-1.6.0/cgroup0707010000001B000081A400000000000000000000000164F6FC3800001074000000000000000000000000000000000000002E00000000homeassistant-os-agent-1.6.0/cgroup/cgroup.gopackage cgroup

import (
	"encoding/json"
	"fmt"
	"os"
	"os/exec"
	"path/filepath"

securejoin "github.com/cyphar/filepath-securejoin"
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath            = "/io/hass/os/CGroup"
	ifaceName             = "io.hass.os.CGroup"
	cgroupFSDockerDevices = "/sys/fs/cgroup/devices/docker"
)

type CGroupVersion int

const (
	CGroupUnknown CGroupVersion = iota
	CGroupV1
	CGroupV2
)

type cgroup struct {
	conn          *dbus.Conn
	cgroupVersion CGroupVersion
}

func (d cgroup) AddDevicesAllowed(containerID string, permission string) (bool, *dbus.Error) {
	if d.cgroupVersion == CGroupV2 {
		permissions := []string{permission}
		resources, err := CreateDeviceUpdateResources(permissions)
		if err != nil {
			error := fmt.Errorf("Error creating device resources for '%s': %w", containerID, err)
			logging.Error.Printf("%s", error)
			return false, dbus.MakeFailedError(error)
		}

cmd := exec.Command("runc", "--root", "/var/run/docker/runtime-runc/moby/", "update", "--resources", "-", containerID)

// Pass resources as OCI LinuxResources JSON object
		stdin, err := cmd.StdinPipe()
		if err != nil {
			error := fmt.Errorf("Error creating stdin pipe for '%s': %w", containerID, err)
			logging.Error.Printf("%s", error)
			return false, dbus.MakeFailedError(error)
		}
		enc := json.NewEncoder(stdin)
		err = enc.Encode(resources)
		if err != nil {
			error := fmt.Errorf("Error encoding JSON for '%s': %w", containerID, err)
			logging.Error.Printf("%s", error)
			return false, dbus.MakeFailedError(error)
		}
		stdin.Close()

stdoutStderr, err := cmd.CombinedOutput()
		if err != nil {
			error := fmt.Errorf("Error calling runc for '%s': %w, output %s", containerID, err, stdoutStderr)
			logging.Error.Printf("%s", error)
			return false, dbus.MakeFailedError(error)
		} else {
			logging.Info.Printf("Successfully called runc for '%s', output %s", containerID, stdoutStderr)
		}

logging.Info.Printf("Permission '%s', granted for Container '%s' via runc", permission, containerID)
		return true, nil
	} else {
		// Make sure path is relative to cgroupFSDockerDevices
		allowedFile, err := securejoin.SecureJoin(cgroupFSDockerDevices, containerID+string(filepath.Separator)+"devices.allow")
		if err != nil {
			return false, dbus.MakeFailedError(fmt.Errorf("Security issues with '%s': %w", containerID, err))
		}

// Check if file/container exists
		_, err = os.Stat(allowedFile)
		if os.IsNotExist(err) {
			return false, dbus.MakeFailedError(fmt.Errorf("Can't find Container '%s' for adjust CGroup devices.", containerID))
		}

// Write permission adjustments
		file, err := os.Create(allowedFile)
		if err != nil {
			return false, dbus.MakeFailedError(fmt.Errorf("Can't open CGroup devices '%s': %w", allowedFile, err))
		}
		defer file.Close()

_, err = file.WriteString(permission + "\n")
		if err != nil {
			return false, dbus.MakeFailedError(fmt.Errorf("Can't write CGroup permission '%s': %w", permission, err))
		}

logging.Info.Printf("Permission '%s', granted for Container '%s' via CGroup devices.allow", permission, containerID)
		return true, nil
	}
}

func InitializeDBus(conn *dbus.Conn) {
	d := cgroup{
		conn:          conn,
		cgroupVersion: CGroupUnknown,
	}

// Check for CGroups v2
	if _, err := os.Stat("/sys/fs/cgroup/cgroup.controllers"); err == nil {
		d.cgroupVersion = CGroupV2
		logging.Info.Printf("Detected CGroups Version 2")
	} else {
		d.cgroupVersion = CGroupV1
		logging.Info.Printf("Detected CGroups Version 1")
	}

err := conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

node := &introspect.Node{
		Name: objectPath,
		Interfaces: []introspect.Interface{
			introspect.IntrospectData,
			prop.IntrospectData,
			{
				Name:    ifaceName,
				Methods: introspect.Methods(d),
			},
		},
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
0707010000001C000081A400000000000000000000000164F6FC38000006C9000000000000000000000000000000000000002B00000000homeassistant-os-agent-1.6.0/cgroup/oci.gopackage cgroup

import (
	"fmt"
	"regexp"
	"strconv"

"github.com/opencontainers/runtime-spec/specs-go"
)

var deviceCgroupRuleRegex = regexp.MustCompile(`^([acb]) ([0-9]+|\*):([0-9]+|\*) ([rwm]{1,3})$`)

// Lifted from Moby's oci/oci.go
func AppendDevicePermissionsFromCgroupRules(devPermissions []specs.LinuxDeviceCgroup, rules []string) ([]specs.LinuxDeviceCgroup, error) {
	for _, deviceCgroupRule := range rules {
		ss := deviceCgroupRuleRegex.FindAllStringSubmatch(deviceCgroupRule, -1)
		if len(ss) == 0 || len(ss[0]) != 5 {
			return nil, fmt.Errorf("invalid device cgroup rule format: '%s'", deviceCgroupRule)
		}
		matches := ss[0]

dPermissions := specs.LinuxDeviceCgroup{
			Allow:  true,
			Type:   matches[1],
			Access: matches[4],
		}
		if matches[2] == "*" {
			major := int64(-1)
			dPermissions.Major = &major
		} else {
			major, err := strconv.ParseInt(matches[2], 10, 64)
			if err != nil {
				return nil, fmt.Errorf("invalid major value in device cgroup rule format: '%s'", deviceCgroupRule)
			}
			dPermissions.Major = &major
		}
		if matches[3] == "*" {
			minor := int64(-1)
			dPermissions.Minor = &minor
		} else {
			minor, err := strconv.ParseInt(matches[3], 10, 64)
			if err != nil {
				return nil, fmt.Errorf("invalid minor value in device cgroup rule format: '%s'", deviceCgroupRule)
			}
			dPermissions.Minor = &minor
		}
		devPermissions = append(devPermissions, dPermissions)
	}
	return devPermissions, nil
}

func CreateDeviceUpdateResources(rules []string) (*specs.LinuxResources, error) {
	resources := specs.LinuxResources{}

devices, err := AppendDevicePermissionsFromCgroupRules(nil, rules)
	if err != nil {
		return nil, err
	}

resources.Devices = devices

return &resources, nil
}
0707010000001D000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002500000000homeassistant-os-agent-1.6.0/contrib0707010000001E000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002C00000000homeassistant-os-agent-1.6.0/contrib/debian0707010000001F000081A400000000000000000000000164F6FC380000005B000000000000000000000000000000000000003B00000000homeassistant-os-agent-1.6.0/contrib/debian/postinstall.sh#!/bin/bash
systemctl daemon-reload
systemctl enable haos-agent
systemctl start haos-agent
07070100000020000081A400000000000000000000000164F6FC3800000024000000000000000000000000000000000000003A00000000homeassistant-os-agent-1.6.0/contrib/debian/postremove.sh#!/bin/bash
systemctl daemon-reload
07070100000021000081A400000000000000000000000164F6FC3800000043000000000000000000000000000000000000003900000000homeassistant-os-agent-1.6.0/contrib/debian/preremove.sh#!/bin/bash
systemctl stop haos-agent
systemctl disable haos-agent
07070100000022000081A400000000000000000000000164F6FC380000014E000000000000000000000000000000000000003800000000homeassistant-os-agent-1.6.0/contrib/haos-agent.service[Unit]
Description=Home Assistant OS Agent
DefaultDependencies=no
Requires=dbus.socket udisks2.service
After=dbus.socket

[Service]
BusName=io.hass.os
Type=notify
Restart=always
RestartSec=5s
Environment="DBUS_SYSTEM_BUS_ADDRESS=unix:path=/run/dbus/system_bus_socket"
ExecStart=/usr/bin/os-agent

[Install]
WantedBy=multi-user.target
07070100000023000081A400000000000000000000000164F6FC38000001F8000000000000000000000000000000000000003200000000homeassistant-os-agent-1.6.0/contrib/io.hass.conf<!DOCTYPE busconfig PUBLIC
          "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
          "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
<busconfig>
  
  <policy user="root">
    <allow own="io.hass.os"/>
  </policy>
  <policy group="root">
    <allow own="io.hass.os"/>
  </policy>

<policy context="default">
    <allow send_destination="io.hass.os"/>
    <allow receive_sender="io.hass.os"/>
  </policy>
</busconfig>
07070100000024000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002600000000homeassistant-os-agent-1.6.0/datadisk07070100000025000081A400000000000000000000000164F6FC3800000DB7000000000000000000000000000000000000003200000000homeassistant-os-agent-1.6.0/datadisk/datadisk.gopackage datadisk

import (
	"errors"
	"fmt"
	"os"

"github.com/fntlnz/mountinfo"
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

"github.com/home-assistant/os-agent/udisks2"
	logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	dataMount              = "/mnt/data"
	linuxDataPartitionUUID = "0FC63DAF-8483-4772-8E79-3D69D8477DE4"
)

func GetDataMount() (*mountinfo.Mountinfo, error) {

minfo, err := mountinfo.GetMountInfo("/proc/self/mountinfo")
	if err != nil {
		logging.Warning.Print(err)
		return nil, err
	}

for _, info := range minfo {
		if dataMount == info.MountPoint {
			return &info, nil
		}
	}
	return nil, errors.New("Can't find a data mount!")
}

type datadisk struct {
	conn  *dbus.Conn
	props *prop.Properties
}

func (d datadisk) MarkDataMove() *dbus.Error {
	/* Move request marker for hassos-data.service */
	fileName := "/mnt/overlay/move-data"
	_, err := os.Stat(fileName)
	if os.IsNotExist(err) {
		file, err := os.Create(fileName)
		if err != nil {
			return dbus.MakeFailedError(err)
		}
		defer file.Close()
	}

return nil
}

func (d datadisk) ChangeDevice(newDevice string) (bool, *dbus.Error) {
	logging.Info.Printf("Request to change data disk to %s.", newDevice)

udisks2helper := udisks2.NewUDisks2(d.conn)
	dataDevice, err := udisks2helper.GetRootDeviceFromLabel("hassos-data")
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}

logging.Info.Printf("Data partition is currently on device %s.", *dataDevice)
	if *dataDevice == newDevice {
		return false, dbus.MakeFailedError(fmt.Errorf("Current data device \"%s\" the same as target device. Aborting.", *dataDevice))
	}

err = udisks2helper.PartitionDeviceWithSinglePartition(newDevice, linuxDataPartitionUUID, "hassos-data-external")
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}

dbuserr := d.MarkDataMove()
	if dbuserr != nil {
		return false, dbuserr
	}

return true, nil
}

func (d datadisk) ReloadDevice() (bool, *dbus.Error) {
	mountInfo, err := GetDataMount()
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}

d.props.SetMust(ifaceName, "CurrentDevice", mountInfo.MountSource)
	return true, nil
}

const (
	objectPath = "/io/hass/os/DataDisk"
	ifaceName  = "io.hass.os.DataDisk"
)

func InitializeDBus(conn *dbus.Conn) {

// Try to read the current data mount point
	mountInfo, err := GetDataMount()
	var currentDisk string = ""
	if err != nil {
		logging.Warning.Print(err)
	} else {
		currentDisk = mountInfo.MountSource
	}

d := datadisk{
		conn: conn,
	}

propsSpec := map[string]map[string]*prop.Prop{
		ifaceName: {
			"CurrentDevice": {
				Value:    &currentDisk,
				Writable: false,
				Emit:     prop.EmitTrue,
				Callback: nil,
			},
		},
	}
	props, err := prop.Export(conn, objectPath, propsSpec)
	if err != nil {
		logging.Critical.Panic(err)
	}
	d.props = props

err = conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
07070100000026000081A400000000000000000000000164F6FC38000001B1000000000000000000000000000000000000002400000000homeassistant-os-agent-1.6.0/go.modmodule github.com/home-assistant/os-agent

go 1.19

require (
	github.com/coreos/go-systemd/v22 v22.5.0
	github.com/cyphar/filepath-securejoin v0.2.3
	github.com/fntlnz/mountinfo v1.0.1
	github.com/getsentry/sentry-go v0.23.0
	github.com/godbus/dbus/v5 v5.1.0
	github.com/natefinch/atomic v1.0.1
	github.com/opencontainers/runtime-spec v1.1.0
)

require (
	golang.org/x/sys v0.6.0 // indirect
	golang.org/x/text v0.8.0 // indirect
)
07070100000027000081A400000000000000000000000164F6FC3800000901000000000000000000000000000000000000002400000000homeassistant-os-agent-1.6.0/go.sumgithub.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
github.com/cyphar/filepath-securejoin v0.2.3 h1:YX6ebbZCZP7VkM3scTTokDgBL2TY741X51MTk3ycuNI=
github.com/cyphar/filepath-securejoin v0.2.3/go.mod h1:aPGpWjXOXUn2NCNjFvBE6aRxGGx79pTxQpKOJNYHHl4=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/fntlnz/mountinfo v1.0.1 h1:I06izqp+/BwMPjdhuNnCZWOaOs5EaFFLXKdFB/lfKxk=
github.com/fntlnz/mountinfo v1.0.1/go.mod h1:k6q/bWiHuceDCdNRih4YtGy99p8LROjL5dBH6D9/lhg=
github.com/getsentry/sentry-go v0.23.0 h1:dn+QRCeJv4pPt9OjVXiMcGIBIefaTJPw/h0bZWO05nE=
github.com/getsentry/sentry-go v0.23.0/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY=
github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxIA=
github.com/godbus/dbus/v5 v5.0.4/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/godbus/dbus/v5 v5.1.0 h1:4KLkAxT3aOY8Li4FRJe/KvhoNFFxo0m6fNuFUO8QJUk=
github.com/godbus/dbus/v5 v5.1.0/go.mod h1:xhWf0FNVPg57R7Z0UbKHbJfkEywrmjJnf7w5xrFpKfA=
github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
github.com/natefinch/atomic v1.0.1 h1:ZPYKxkqQOx3KZ+RsbnP/YsgvxWQPGxjC0oBt2AhwV0A=
github.com/natefinch/atomic v1.0.1/go.mod h1:N/D/ELrljoqDyT3rZrsUmtsuzvHkeB/wWjHV22AZRbM=
github.com/opencontainers/runtime-spec v1.1.0 h1:HHUyrt9mwHUjtasSbXSMvs4cyFxh+Bll4AjJ9odEGpg=
github.com/opencontainers/runtime-spec v1.1.0/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/stretchr/testify v1.8.2 h1:+h33VjcLVPDHtOdpUCuF+7gSuG3yGIftsP1YvFihtJ8=
golang.org/x/sys v0.6.0 h1:MVltZSvRTcU2ljQOhs94SXPftV6DCNnZViHeQps87pQ=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68=
golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
07070100000028000081A400000000000000000000000164F6FC3800000BB0000000000000000000000000000000000000002500000000homeassistant-os-agent-1.6.0/main.gopackage main

import (
	"time"

"github.com/coreos/go-systemd/v22/daemon"
	"github.com/getsentry/sentry-go"
	"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

"github.com/home-assistant/os-agent/apparmor"
	"github.com/home-assistant/os-agent/boards"
	"github.com/home-assistant/os-agent/cgroup"
	"github.com/home-assistant/os-agent/datadisk"
	"github.com/home-assistant/os-agent/system"
	logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	busName    = "io.hass.os"
	objectPath = "/io/hass/os"
	sentryDsn  = "https://c74e811a96e4413a95caaaa5ae05f851@o427061.ingest.sentry.io/5710878"
)

var (
	// version and baord are set at link time via -X flag
	version       string = "dev"
	board         string = "unknown"
	enableCapture bool   = false
)

func main() {
	logging.Info.Printf("Start OS-Agent %s", version)

// Sentry
	err := sentry.Init(sentry.ClientOptions{
		Dsn:        sentryDsn,
		Release:    version,
		BeforeSend: filterSentry,
	})
	if err != nil {
		logging.Critical.Fatalf("Sentry init: %s", err)
	}

defer sentry.Flush(2 * time.Second)
	defer sentry.Recover()

// Connect DBus
	conn, err := dbus.SystemBus()
	if err != nil {
		logging.Critical.Fatalf("DBus connection: %s", err)
	}

// Init Dbus io.hass.os
	reply, err := conn.RequestName(busName, dbus.NameFlagDoNotQueue)
	if err != nil {
		logging.Critical.Panic(err)
	}
	if reply != dbus.RequestNameReplyPrimaryOwner {
		logging.Critical.Fatalf("name already taken")
	}

// Set base Property / functionality
	InitializeDBus(conn)

logging.Info.Printf("Listening on service %s ...", busName)
	datadisk.InitializeDBus(conn)
	system.InitializeDBus(conn)
	apparmor.InitializeDBus(conn)
	cgroup.InitializeDBus(conn)
	boards.InitializeDBus(conn, board)

_, err = daemon.SdNotify(false, daemon.SdNotifyReady)
	if err != nil {
		logging.Critical.Panic(err)
	}
	select {}
}

func InitializeDBus(conn *dbus.Conn) {
	propsSpec := map[string]map[string]*prop.Prop{
		busName: {
			"Version": {
				Value:    version,
				Writable: false,
				Emit:     prop.EmitInvalidates,
				Callback: nil,
			},
			"Diagnostics": {
				Value:    enableCapture,
				Writable: true,
				Emit:     prop.EmitTrue,
				Callback: func(c *prop.Change) *dbus.Error {
					logging.Info.Printf("Diagnostics is now %t", c.Value)
					enableCapture = c.Value.(bool)
					return nil
				},
			},
		},
	}

props, err := prop.Export(conn, objectPath, propsSpec)
	if err != nil {
		logging.Critical.Panic(err)
	}

node := &introspect.Node{
		Name: objectPath,
		Interfaces: []introspect.Interface{
			introspect.IntrospectData,
			prop.IntrospectData,
			{
				Name:       busName,
				Properties: props.Introspection(busName),
			},
		},
	}
	err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, busName)
}
07070100000029000081A400000000000000000000000164F6FC38000000CF000000000000000000000000000000000000002700000000homeassistant-os-agent-1.6.0/sentry.gopackage main

import "github.com/getsentry/sentry-go"

func filterSentry(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
	if version == "dev" || !enableCapture {
		return nil
	}
	return event
}
0707010000002A000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002400000000homeassistant-os-agent-1.6.0/system0707010000002B000081A400000000000000000000000164F6FC38000010E9000000000000000000000000000000000000002E00000000homeassistant-os-agent-1.6.0/system/system.gopackage system

import (
	"context"
	"fmt"
	"os"
	"strings"

"github.com/godbus/dbus/v5"
	"github.com/godbus/dbus/v5/introspect"
	"github.com/godbus/dbus/v5/prop"

"github.com/home-assistant/os-agent/udisks2"
	logging "github.com/home-assistant/os-agent/utils/log"
)

const (
	objectPath             = "/io/hass/os/System"
	ifaceName              = "io.hass.os.System"
	labelDataFileSystem    = "hassos-data"
	labelOverlayFileSystem = "hassos-overlay"
	kernelCommandLine      = "/mnt/boot/cmdline.txt"
	tmpKernelCommandLine   = "/mnt/boot/.tmp.cmdline.txt"
	sshAuthKeyFileName     = "/root/.ssh/authorized_keys"
)

type system struct {
	conn *dbus.Conn
}

func getAndCheckBusObjectFromLabel(udisks2helper udisks2.UDisks2Helper, label string) (dbus.BusObject, error) {
	dataBusObject, err := udisks2helper.GetBusObjectFromLabel(label)
	if err != nil {
		return nil, dbus.MakeFailedError(err)
	}

dataFilesystem := udisks2.NewFilesystem(dataBusObject)
	dataMountPoints, err := dataFilesystem.GetMountPointsString(context.Background())
	if err != nil {
		return nil, dbus.MakeFailedError(err)
	}

if len(dataMountPoints) > 0 {
		return nil, dbus.MakeFailedError(fmt.Errorf("Device with label \"%s\" is mounted at %s, aborting.", label, dataMountPoints))
	}

return dataBusObject, nil
}

func (d system) WipeDevice() (bool, *dbus.Error) {
	logging.Info.Printf("Wipe device data.")

udisks2helper := udisks2.NewUDisks2(d.conn)
	dataBusObject, err := getAndCheckBusObjectFromLabel(udisks2helper, labelDataFileSystem)
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}

overlayBusObject, err := getAndCheckBusObjectFromLabel(udisks2helper, labelOverlayFileSystem)
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}

err = udisks2helper.FormatPartition(dataBusObject, "ext4", labelDataFileSystem)
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}
	err = udisks2helper.FormatPartition(overlayBusObject, "ext4", labelOverlayFileSystem)
	if err != nil {
		return false, dbus.MakeFailedError(err)
	}
	logging.Info.Printf("Successfully wiped device data.")

return true, nil
}

func (d system) ScheduleWipeDevice() (bool, *dbus.Error) {

data, err := os.ReadFile(kernelCommandLine)
	if err != nil {
		fmt.Println(err)
		return false, dbus.MakeFailedError(err)
	}

datastr := strings.TrimSpace(string(data))
	datastr += " haos.wipe=1"

err = os.WriteFile(tmpKernelCommandLine, []byte(datastr), 0644) //nolint:gosec
	if err != nil {
		fmt.Println(err)
		return false, dbus.MakeFailedError(err)
	}

// Boot is mounted sync on Home Assistant OS, so just rename should be fine.
	err = os.Rename(tmpKernelCommandLine, kernelCommandLine)
	if err != nil {
		fmt.Println(err)
		return false, dbus.MakeFailedError(err)
	}

logging.Info.Printf("Device will get wiped on next reboot!")
	return true, nil
}

func (d system) AddSSHAuthKey(newKey string) *dbus.Error {

file, err := os.OpenFile(sshAuthKeyFileName, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		logging.Error.Printf("Failed to open SSH authentication file %s: %s", sshAuthKeyFileName, err)
		return dbus.MakeFailedError(err)
	}

defer file.Close()

if _, err := file.WriteString(newKey + "\n"); err != nil {
		logging.Error.Printf("Failed to write SSH authentication file: %s.", err)
		return dbus.MakeFailedError(err)
	}

logging.Info.Printf("New SSH authentication key added for user root.")

return nil
}

func (d system) ClearSSHAuthKeys() *dbus.Error {
	if err := os.Remove(sshAuthKeyFileName); err != nil && os.IsNotExist(err) {
		logging.Error.Printf("Failed to delete SSH authentication file %s: %s", sshAuthKeyFileName, err)
		return dbus.MakeFailedError(err)
	}

return nil
}

func InitializeDBus(conn *dbus.Conn) {
	d := system{
		conn: conn,
	}

err := conn.Export(d, objectPath, ifaceName)
	if err != nil {
		logging.Critical.Panic(err)
	}

node := &introspect.Node{
		Name: objectPath,
		Interfaces: []introspect.Interface{
			introspect.IntrospectData,
			prop.IntrospectData,
			{
				Name:    ifaceName,
				Methods: introspect.Methods(d),
			},
		},
	}

err = conn.Export(introspect.NewIntrospectable(node), objectPath, "org.freedesktop.DBus.Introspectable")
	if err != nil {
		logging.Critical.Panic(err)
	}

logging.Info.Printf("Exposing object %s with interface %s ...", objectPath, ifaceName)
}
0707010000002C000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002500000000homeassistant-os-agent-1.6.0/udisks20707010000002D000081A400000000000000000000000164F6FC38000104BD000000000000000000000000000000000000002C00000000homeassistant-os-agent-1.6.0/udisks2/api.go// Code generated by dbus-codegen-go DO NOT EDIT.
package udisks2

import (
	"context"
	"errors"
	"fmt"
	"github.com/godbus/dbus/v5"
)

// Signal is a common interface for all signals.
type Signal interface {
	Name() string
	Interface() string
	Sender() string

path() dbus.ObjectPath
	values() []interface{}
}

// ErrUnknownSignal is returned by LookupSignal when a signal cannot be resolved.
var ErrUnknownSignal = errors.New("unknown signal")

// LookupSignal converts the given raw D-Bus signal with variable body
// into one with typed structured body or returns ErrUnknownSignal error.
func LookupSignal(signal *dbus.Signal) (Signal, error) {
	switch signal.Name {
	case InterfaceJob + "." + "Completed":
		v0, ok := signal.Body[0].(bool)
		if !ok {
			return nil, fmt.Errorf("prop .Success is %T, not bool", signal.Body[0])
		}
		v1, ok := signal.Body[1].(string)
		if !ok {
			return nil, fmt.Errorf("prop .Message is %T, not string", signal.Body[1])
		}
		return &JobCompletedSignal{
			sender: signal.Sender,
			Path:   signal.Path,
			Body: &JobCompletedSignalBody{
				Success: v0,
				Message: v1,
			},
		}, nil
	default:
		return nil, ErrUnknownSignal
	}
}

// AddMatchSignal registers a match rule for the given signal,
// opts are appended to the automatically generated signal's rules.
func AddMatchSignal(conn *dbus.Conn, s Signal, opts ...dbus.MatchOption) error {
	return conn.AddMatchSignal(append([]dbus.MatchOption{
		dbus.WithMatchInterface(s.Interface()),
		dbus.WithMatchMember(s.Name()),
	}, opts...)...)
}

// RemoveMatchSignal unregisters the previously registered subscription.
func RemoveMatchSignal(conn *dbus.Conn, s Signal, opts ...dbus.MatchOption) error {
	return conn.RemoveMatchSignal(append([]dbus.MatchOption{
		dbus.WithMatchInterface(s.Interface()),
		dbus.WithMatchMember(s.Name()),
	}, opts...)...)
}

// Interface name constants.
const (
	InterfaceManager        = "org.freedesktop.UDisks2.Manager"
	InterfaceDrive          = "org.freedesktop.UDisks2.Drive"
	InterfaceDriveAta       = "org.freedesktop.UDisks2.Drive.Ata"
	InterfaceBlock          = "org.freedesktop.UDisks2.Block"
	InterfacePartitionTable = "org.freedesktop.UDisks2.PartitionTable"
	InterfacePartition      = "org.freedesktop.UDisks2.Partition"
	InterfaceFilesystem     = "org.freedesktop.UDisks2.Filesystem"
	InterfaceSwapspace      = "org.freedesktop.UDisks2.Swapspace"
	InterfaceEncrypted      = "org.freedesktop.UDisks2.Encrypted"
	InterfaceLoop           = "org.freedesktop.UDisks2.Loop"
	InterfaceMDRaid         = "org.freedesktop.UDisks2.MDRaid"
	InterfaceJob            = "org.freedesktop.UDisks2.Job"
)

// NewManager creates and allocates org.freedesktop.UDisks2.Manager.
func NewManager(object dbus.BusObject) *Manager {
	return &Manager{object}
}

// Manager implements org.freedesktop.UDisks2.Manager D-Bus interface.
type Manager struct {
	object dbus.BusObject
}

// CanFormat calls org.freedesktop.UDisks2.Manager.CanFormat method.
func (o *Manager) CanFormat(ctx context.Context, inType string) (available struct {
	V0 bool
	V1 string
}, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".CanFormat", 0, inType).Store(&available)
	return
}

// CanResize calls org.freedesktop.UDisks2.Manager.CanResize method.
func (o *Manager) CanResize(ctx context.Context, inType string) (available struct {
	V0 bool
	V1 uint64
	V2 string
}, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".CanResize", 0, inType).Store(&available)
	return
}

// CanCheck calls org.freedesktop.UDisks2.Manager.CanCheck method.
func (o *Manager) CanCheck(ctx context.Context, inType string) (available struct {
	V0 bool
	V1 string
}, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".CanCheck", 0, inType).Store(&available)
	return
}

// CanRepair calls org.freedesktop.UDisks2.Manager.CanRepair method.
func (o *Manager) CanRepair(ctx context.Context, inType string) (available struct {
	V0 bool
	V1 string
}, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".CanRepair", 0, inType).Store(&available)
	return
}

// LoopSetup calls org.freedesktop.UDisks2.Manager.LoopSetup method.
//
// Annotations:
//   @org.gtk.GDBus.C.UnixFD = 1
func (o *Manager) LoopSetup(ctx context.Context, fd dbus.UnixFD, options map[string]dbus.Variant) (resultingDevice dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".LoopSetup", 0, fd, options).Store(&resultingDevice)
	return
}

// MDRaidCreate calls org.freedesktop.UDisks2.Manager.MDRaidCreate method.
func (o *Manager) MDRaidCreate(ctx context.Context, blocks []dbus.ObjectPath, level string, name string, chunk uint64, options map[string]dbus.Variant) (resultingArray dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".MDRaidCreate", 0, blocks, level, name, chunk, options).Store(&resultingArray)
	return
}

// EnableModules calls org.freedesktop.UDisks2.Manager.EnableModules method.
//
// Deprecated will be removed later.
//
// Annotations:
//   @org.freedesktop.DBus.Deprecated = true
func (o *Manager) EnableModules(ctx context.Context, enable bool) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".EnableModules", 0, enable).Store()
	return
}

// EnableModule calls org.freedesktop.UDisks2.Manager.EnableModule method.
func (o *Manager) EnableModule(ctx context.Context, name string, enable bool) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".EnableModule", 0, name, enable).Store()
	return
}

// GetBlockDevices calls org.freedesktop.UDisks2.Manager.GetBlockDevices method.
func (o *Manager) GetBlockDevices(ctx context.Context, options map[string]dbus.Variant) (blockObjects []dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".GetBlockDevices", 0, options).Store(&blockObjects)
	return
}

// ResolveDevice calls org.freedesktop.UDisks2.Manager.ResolveDevice method.
func (o *Manager) ResolveDevice(ctx context.Context, devspec map[string]dbus.Variant, options map[string]dbus.Variant) (devices []dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfaceManager+".ResolveDevice", 0, devspec, options).Store(&devices)
	return
}

// GetVersion gets org.freedesktop.UDisks2.Manager.Version property.
func (o *Manager) GetVersion(ctx context.Context) (version string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceManager, "Version").Store(&version)
	return
}

// GetSupportedFilesystems gets org.freedesktop.UDisks2.Manager.SupportedFilesystems property.
func (o *Manager) GetSupportedFilesystems(ctx context.Context) (supportedFilesystems []string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceManager, "SupportedFilesystems").Store(&supportedFilesystems)
	return
}

// GetSupportedEncryptionTypes gets org.freedesktop.UDisks2.Manager.SupportedEncryptionTypes property.
func (o *Manager) GetSupportedEncryptionTypes(ctx context.Context) (supportedEncryptionTypes []string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceManager, "SupportedEncryptionTypes").Store(&supportedEncryptionTypes)
	return
}

// GetDefaultEncryptionType gets org.freedesktop.UDisks2.Manager.DefaultEncryptionType property.
func (o *Manager) GetDefaultEncryptionType(ctx context.Context) (defaultEncryptionType string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceManager, "DefaultEncryptionType").Store(&defaultEncryptionType)
	return
}

// NewDrive creates and allocates org.freedesktop.UDisks2.Drive.
func NewDrive(object dbus.BusObject) *Drive {
	return &Drive{object}
}

// Drive implements org.freedesktop.UDisks2.Drive D-Bus interface.
type Drive struct {
	object dbus.BusObject
}

// Eject calls org.freedesktop.UDisks2.Drive.Eject method.
func (o *Drive) Eject(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDrive+".Eject", 0, options).Store()
	return
}

// SetConfiguration calls org.freedesktop.UDisks2.Drive.SetConfiguration method.
func (o *Drive) SetConfiguration(ctx context.Context, value map[string]dbus.Variant, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDrive+".SetConfiguration", 0, value, options).Store()
	return
}

// PowerOff calls org.freedesktop.UDisks2.Drive.PowerOff method.
func (o *Drive) PowerOff(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDrive+".PowerOff", 0, options).Store()
	return
}

// GetVendor gets org.freedesktop.UDisks2.Drive.Vendor property.
func (o *Drive) GetVendor(ctx context.Context) (vendor string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Vendor").Store(&vendor)
	return
}

// GetModel gets org.freedesktop.UDisks2.Drive.Model property.
func (o *Drive) GetModel(ctx context.Context) (model string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Model").Store(&model)
	return
}

// GetRevision gets org.freedesktop.UDisks2.Drive.Revision property.
func (o *Drive) GetRevision(ctx context.Context) (revision string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Revision").Store(&revision)
	return
}

// GetSerial gets org.freedesktop.UDisks2.Drive.Serial property.
func (o *Drive) GetSerial(ctx context.Context) (serial string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Serial").Store(&serial)
	return
}

// GetWWN gets org.freedesktop.UDisks2.Drive.WWN property.
func (o *Drive) GetWWN(ctx context.Context) (wWN string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "WWN").Store(&wWN)
	return
}

// GetId gets org.freedesktop.UDisks2.Drive.Id property.
func (o *Drive) GetId(ctx context.Context) (id string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Id").Store(&id)
	return
}

// GetConfiguration gets org.freedesktop.UDisks2.Drive.Configuration property.
func (o *Drive) GetConfiguration(ctx context.Context) (configuration map[string]dbus.Variant, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Configuration").Store(&configuration)
	return
}

// GetMedia gets org.freedesktop.UDisks2.Drive.Media property.
func (o *Drive) GetMedia(ctx context.Context) (media string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Media").Store(&media)
	return
}

// GetMediaCompatibility gets org.freedesktop.UDisks2.Drive.MediaCompatibility property.
func (o *Drive) GetMediaCompatibility(ctx context.Context) (mediaCompatibility []string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "MediaCompatibility").Store(&mediaCompatibility)
	return
}

// GetMediaRemovable gets org.freedesktop.UDisks2.Drive.MediaRemovable property.
func (o *Drive) GetMediaRemovable(ctx context.Context) (mediaRemovable bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "MediaRemovable").Store(&mediaRemovable)
	return
}

// GetMediaAvailable gets org.freedesktop.UDisks2.Drive.MediaAvailable property.
func (o *Drive) GetMediaAvailable(ctx context.Context) (mediaAvailable bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "MediaAvailable").Store(&mediaAvailable)
	return
}

// GetMediaChangeDetected gets org.freedesktop.UDisks2.Drive.MediaChangeDetected property.
func (o *Drive) GetMediaChangeDetected(ctx context.Context) (mediaChangeDetected bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "MediaChangeDetected").Store(&mediaChangeDetected)
	return
}

// GetSize gets org.freedesktop.UDisks2.Drive.Size property.
func (o *Drive) GetSize(ctx context.Context) (size uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Size").Store(&size)
	return
}

// GetTimeDetected gets org.freedesktop.UDisks2.Drive.TimeDetected property.
func (o *Drive) GetTimeDetected(ctx context.Context) (timeDetected uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "TimeDetected").Store(&timeDetected)
	return
}

// GetTimeMediaDetected gets org.freedesktop.UDisks2.Drive.TimeMediaDetected property.
func (o *Drive) GetTimeMediaDetected(ctx context.Context) (timeMediaDetected uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "TimeMediaDetected").Store(&timeMediaDetected)
	return
}

// GetOptical gets org.freedesktop.UDisks2.Drive.Optical property.
func (o *Drive) GetOptical(ctx context.Context) (optical bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Optical").Store(&optical)
	return
}

// GetOpticalBlank gets org.freedesktop.UDisks2.Drive.OpticalBlank property.
func (o *Drive) GetOpticalBlank(ctx context.Context) (opticalBlank bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "OpticalBlank").Store(&opticalBlank)
	return
}

// GetOpticalNumTracks gets org.freedesktop.UDisks2.Drive.OpticalNumTracks property.
func (o *Drive) GetOpticalNumTracks(ctx context.Context) (opticalNumTracks uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "OpticalNumTracks").Store(&opticalNumTracks)
	return
}

// GetOpticalNumAudioTracks gets org.freedesktop.UDisks2.Drive.OpticalNumAudioTracks property.
func (o *Drive) GetOpticalNumAudioTracks(ctx context.Context) (opticalNumAudioTracks uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "OpticalNumAudioTracks").Store(&opticalNumAudioTracks)
	return
}

// GetOpticalNumDataTracks gets org.freedesktop.UDisks2.Drive.OpticalNumDataTracks property.
func (o *Drive) GetOpticalNumDataTracks(ctx context.Context) (opticalNumDataTracks uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "OpticalNumDataTracks").Store(&opticalNumDataTracks)
	return
}

// GetOpticalNumSessions gets org.freedesktop.UDisks2.Drive.OpticalNumSessions property.
func (o *Drive) GetOpticalNumSessions(ctx context.Context) (opticalNumSessions uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "OpticalNumSessions").Store(&opticalNumSessions)
	return
}

// GetRotationRate gets org.freedesktop.UDisks2.Drive.RotationRate property.
func (o *Drive) GetRotationRate(ctx context.Context) (rotationRate int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "RotationRate").Store(&rotationRate)
	return
}

// GetConnectionBus gets org.freedesktop.UDisks2.Drive.ConnectionBus property.
func (o *Drive) GetConnectionBus(ctx context.Context) (connectionBus string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "ConnectionBus").Store(&connectionBus)
	return
}

// GetSeat gets org.freedesktop.UDisks2.Drive.Seat property.
func (o *Drive) GetSeat(ctx context.Context) (seat string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Seat").Store(&seat)
	return
}

// GetRemovable gets org.freedesktop.UDisks2.Drive.Removable property.
func (o *Drive) GetRemovable(ctx context.Context) (removable bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Removable").Store(&removable)
	return
}

// GetEjectable gets org.freedesktop.UDisks2.Drive.Ejectable property.
func (o *Drive) GetEjectable(ctx context.Context) (ejectable bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "Ejectable").Store(&ejectable)
	return
}

// GetSortKey gets org.freedesktop.UDisks2.Drive.SortKey property.
func (o *Drive) GetSortKey(ctx context.Context) (sortKey string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "SortKey").Store(&sortKey)
	return
}

// GetCanPowerOff gets org.freedesktop.UDisks2.Drive.CanPowerOff property.
func (o *Drive) GetCanPowerOff(ctx context.Context) (canPowerOff bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "CanPowerOff").Store(&canPowerOff)
	return
}

// GetSiblingId gets org.freedesktop.UDisks2.Drive.SiblingId property.
func (o *Drive) GetSiblingId(ctx context.Context) (siblingId string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDrive, "SiblingId").Store(&siblingId)
	return
}

// NewDriveAta creates and allocates org.freedesktop.UDisks2.Drive.Ata.
func NewDriveAta(object dbus.BusObject) *DriveAta {
	return &DriveAta{object}
}

// DriveAta implements org.freedesktop.UDisks2.Drive.Ata D-Bus interface.
type DriveAta struct {
	object dbus.BusObject
}

// SmartUpdate calls org.freedesktop.UDisks2.Drive.Ata.SmartUpdate method.
func (o *DriveAta) SmartUpdate(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".SmartUpdate", 0, options).Store()
	return
}

// SmartGetAttributes calls org.freedesktop.UDisks2.Drive.Ata.SmartGetAttributes method.
func (o *DriveAta) SmartGetAttributes(ctx context.Context, options map[string]dbus.Variant) (attributes []struct {
	V0 byte
	V1 string
	V2 uint16
	V3 int32
	V4 int32
	V5 int32
	V6 int64
	V7 int32
	V8 map[string]dbus.Variant
}, err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".SmartGetAttributes", 0, options).Store(&attributes)
	return
}

// SmartSelftestStart calls org.freedesktop.UDisks2.Drive.Ata.SmartSelftestStart method.
func (o *DriveAta) SmartSelftestStart(ctx context.Context, inType string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".SmartSelftestStart", 0, inType, options).Store()
	return
}

// SmartSelftestAbort calls org.freedesktop.UDisks2.Drive.Ata.SmartSelftestAbort method.
func (o *DriveAta) SmartSelftestAbort(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".SmartSelftestAbort", 0, options).Store()
	return
}

// SmartSetEnabled calls org.freedesktop.UDisks2.Drive.Ata.SmartSetEnabled method.
func (o *DriveAta) SmartSetEnabled(ctx context.Context, value bool, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".SmartSetEnabled", 0, value, options).Store()
	return
}

// PmGetState calls org.freedesktop.UDisks2.Drive.Ata.PmGetState method.
func (o *DriveAta) PmGetState(ctx context.Context, options map[string]dbus.Variant) (state byte, err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".PmGetState", 0, options).Store(&state)
	return
}

// PmStandby calls org.freedesktop.UDisks2.Drive.Ata.PmStandby method.
func (o *DriveAta) PmStandby(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".PmStandby", 0, options).Store()
	return
}

// PmWakeup calls org.freedesktop.UDisks2.Drive.Ata.PmWakeup method.
func (o *DriveAta) PmWakeup(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".PmWakeup", 0, options).Store()
	return
}

// SecurityEraseUnit calls org.freedesktop.UDisks2.Drive.Ata.SecurityEraseUnit method.
func (o *DriveAta) SecurityEraseUnit(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceDriveAta+".SecurityEraseUnit", 0, options).Store()
	return
}

// GetSmartSupported gets org.freedesktop.UDisks2.Drive.Ata.SmartSupported property.
func (o *DriveAta) GetSmartSupported(ctx context.Context) (smartSupported bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartSupported").Store(&smartSupported)
	return
}

// GetSmartEnabled gets org.freedesktop.UDisks2.Drive.Ata.SmartEnabled property.
func (o *DriveAta) GetSmartEnabled(ctx context.Context) (smartEnabled bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartEnabled").Store(&smartEnabled)
	return
}

// GetSmartUpdated gets org.freedesktop.UDisks2.Drive.Ata.SmartUpdated property.
func (o *DriveAta) GetSmartUpdated(ctx context.Context) (smartUpdated uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartUpdated").Store(&smartUpdated)
	return
}

// GetSmartFailing gets org.freedesktop.UDisks2.Drive.Ata.SmartFailing property.
func (o *DriveAta) GetSmartFailing(ctx context.Context) (smartFailing bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartFailing").Store(&smartFailing)
	return
}

// GetSmartPowerOnSeconds gets org.freedesktop.UDisks2.Drive.Ata.SmartPowerOnSeconds property.
func (o *DriveAta) GetSmartPowerOnSeconds(ctx context.Context) (smartPowerOnSeconds uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartPowerOnSeconds").Store(&smartPowerOnSeconds)
	return
}

// GetSmartTemperature gets org.freedesktop.UDisks2.Drive.Ata.SmartTemperature property.
func (o *DriveAta) GetSmartTemperature(ctx context.Context) (smartTemperature float64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartTemperature").Store(&smartTemperature)
	return
}

// GetSmartNumAttributesFailing gets org.freedesktop.UDisks2.Drive.Ata.SmartNumAttributesFailing property.
func (o *DriveAta) GetSmartNumAttributesFailing(ctx context.Context) (smartNumAttributesFailing int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartNumAttributesFailing").Store(&smartNumAttributesFailing)
	return
}

// GetSmartNumAttributesFailedInThePast gets org.freedesktop.UDisks2.Drive.Ata.SmartNumAttributesFailedInThePast property.
func (o *DriveAta) GetSmartNumAttributesFailedInThePast(ctx context.Context) (smartNumAttributesFailedInThePast int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartNumAttributesFailedInThePast").Store(&smartNumAttributesFailedInThePast)
	return
}

// GetSmartNumBadSectors gets org.freedesktop.UDisks2.Drive.Ata.SmartNumBadSectors property.
func (o *DriveAta) GetSmartNumBadSectors(ctx context.Context) (smartNumBadSectors int64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartNumBadSectors").Store(&smartNumBadSectors)
	return
}

// GetSmartSelftestStatus gets org.freedesktop.UDisks2.Drive.Ata.SmartSelftestStatus property.
func (o *DriveAta) GetSmartSelftestStatus(ctx context.Context) (smartSelftestStatus string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartSelftestStatus").Store(&smartSelftestStatus)
	return
}

// GetSmartSelftestPercentRemaining gets org.freedesktop.UDisks2.Drive.Ata.SmartSelftestPercentRemaining property.
func (o *DriveAta) GetSmartSelftestPercentRemaining(ctx context.Context) (smartSelftestPercentRemaining int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SmartSelftestPercentRemaining").Store(&smartSelftestPercentRemaining)
	return
}

// GetPmSupported gets org.freedesktop.UDisks2.Drive.Ata.PmSupported property.
func (o *DriveAta) GetPmSupported(ctx context.Context) (pmSupported bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "PmSupported").Store(&pmSupported)
	return
}

// GetPmEnabled gets org.freedesktop.UDisks2.Drive.Ata.PmEnabled property.
func (o *DriveAta) GetPmEnabled(ctx context.Context) (pmEnabled bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "PmEnabled").Store(&pmEnabled)
	return
}

// GetApmSupported gets org.freedesktop.UDisks2.Drive.Ata.ApmSupported property.
func (o *DriveAta) GetApmSupported(ctx context.Context) (apmSupported bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "ApmSupported").Store(&apmSupported)
	return
}

// GetApmEnabled gets org.freedesktop.UDisks2.Drive.Ata.ApmEnabled property.
func (o *DriveAta) GetApmEnabled(ctx context.Context) (apmEnabled bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "ApmEnabled").Store(&apmEnabled)
	return
}

// GetAamSupported gets org.freedesktop.UDisks2.Drive.Ata.AamSupported property.
func (o *DriveAta) GetAamSupported(ctx context.Context) (aamSupported bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "AamSupported").Store(&aamSupported)
	return
}

// GetAamEnabled gets org.freedesktop.UDisks2.Drive.Ata.AamEnabled property.
func (o *DriveAta) GetAamEnabled(ctx context.Context) (aamEnabled bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "AamEnabled").Store(&aamEnabled)
	return
}

// GetAamVendorRecommendedValue gets org.freedesktop.UDisks2.Drive.Ata.AamVendorRecommendedValue property.
func (o *DriveAta) GetAamVendorRecommendedValue(ctx context.Context) (aamVendorRecommendedValue int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "AamVendorRecommendedValue").Store(&aamVendorRecommendedValue)
	return
}

// GetWriteCacheSupported gets org.freedesktop.UDisks2.Drive.Ata.WriteCacheSupported property.
func (o *DriveAta) GetWriteCacheSupported(ctx context.Context) (writeCacheSupported bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "WriteCacheSupported").Store(&writeCacheSupported)
	return
}

// GetWriteCacheEnabled gets org.freedesktop.UDisks2.Drive.Ata.WriteCacheEnabled property.
func (o *DriveAta) GetWriteCacheEnabled(ctx context.Context) (writeCacheEnabled bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "WriteCacheEnabled").Store(&writeCacheEnabled)
	return
}

// GetReadLookaheadSupported gets org.freedesktop.UDisks2.Drive.Ata.ReadLookaheadSupported property.
func (o *DriveAta) GetReadLookaheadSupported(ctx context.Context) (readLookaheadSupported bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "ReadLookaheadSupported").Store(&readLookaheadSupported)
	return
}

// GetReadLookaheadEnabled gets org.freedesktop.UDisks2.Drive.Ata.ReadLookaheadEnabled property.
func (o *DriveAta) GetReadLookaheadEnabled(ctx context.Context) (readLookaheadEnabled bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "ReadLookaheadEnabled").Store(&readLookaheadEnabled)
	return
}

// GetSecurityEraseUnitMinutes gets org.freedesktop.UDisks2.Drive.Ata.SecurityEraseUnitMinutes property.
func (o *DriveAta) GetSecurityEraseUnitMinutes(ctx context.Context) (securityEraseUnitMinutes int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SecurityEraseUnitMinutes").Store(&securityEraseUnitMinutes)
	return
}

// GetSecurityEnhancedEraseUnitMinutes gets org.freedesktop.UDisks2.Drive.Ata.SecurityEnhancedEraseUnitMinutes property.
func (o *DriveAta) GetSecurityEnhancedEraseUnitMinutes(ctx context.Context) (securityEnhancedEraseUnitMinutes int32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SecurityEnhancedEraseUnitMinutes").Store(&securityEnhancedEraseUnitMinutes)
	return
}

// GetSecurityFrozen gets org.freedesktop.UDisks2.Drive.Ata.SecurityFrozen property.
func (o *DriveAta) GetSecurityFrozen(ctx context.Context) (securityFrozen bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceDriveAta, "SecurityFrozen").Store(&securityFrozen)
	return
}

// NewBlock creates and allocates org.freedesktop.UDisks2.Block.
func NewBlock(object dbus.BusObject) *Block {
	return &Block{object}
}

// Block implements org.freedesktop.UDisks2.Block D-Bus interface.
type Block struct {
	object dbus.BusObject
}

// AddConfigurationItem calls org.freedesktop.UDisks2.Block.AddConfigurationItem method.
func (o *Block) AddConfigurationItem(ctx context.Context, item struct {
	V0 string
	V1 map[string]dbus.Variant
}, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".AddConfigurationItem", 0, item, options).Store()
	return
}

// RemoveConfigurationItem calls org.freedesktop.UDisks2.Block.RemoveConfigurationItem method.
func (o *Block) RemoveConfigurationItem(ctx context.Context, item struct {
	V0 string
	V1 map[string]dbus.Variant
}, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".RemoveConfigurationItem", 0, item, options).Store()
	return
}

// UpdateConfigurationItem calls org.freedesktop.UDisks2.Block.UpdateConfigurationItem method.
func (o *Block) UpdateConfigurationItem(ctx context.Context, oldItem struct {
	V0 string
	V1 map[string]dbus.Variant
}, newItem struct {
	V0 string
	V1 map[string]dbus.Variant
}, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".UpdateConfigurationItem", 0, oldItem, newItem, options).Store()
	return
}

// GetSecretConfiguration calls org.freedesktop.UDisks2.Block.GetSecretConfiguration method.
func (o *Block) GetSecretConfiguration(ctx context.Context, options map[string]dbus.Variant) (configuration []struct {
	V0 string
	V1 map[string]dbus.Variant
}, err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".GetSecretConfiguration", 0, options).Store(&configuration)
	return
}

// Format calls org.freedesktop.UDisks2.Block.Format method.
func (o *Block) Format(ctx context.Context, inType string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".Format", 0, inType, options).Store()
	return
}

// OpenForBackup calls org.freedesktop.UDisks2.Block.OpenForBackup method.
//
// Annotations:
//   @org.gtk.GDBus.C.UnixFD = 1
func (o *Block) OpenForBackup(ctx context.Context, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".OpenForBackup", 0, options).Store(&fd)
	return
}

// OpenForRestore calls org.freedesktop.UDisks2.Block.OpenForRestore method.
//
// Annotations:
//   @org.gtk.GDBus.C.UnixFD = 1
func (o *Block) OpenForRestore(ctx context.Context, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".OpenForRestore", 0, options).Store(&fd)
	return
}

// OpenForBenchmark calls org.freedesktop.UDisks2.Block.OpenForBenchmark method.
//
// Annotations:
//   @org.gtk.GDBus.C.UnixFD = 1
func (o *Block) OpenForBenchmark(ctx context.Context, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".OpenForBenchmark", 0, options).Store(&fd)
	return
}

// OpenDevice calls org.freedesktop.UDisks2.Block.OpenDevice method.
//
// Annotations:
//   @org.gtk.GDBus.C.UnixFD = 1
func (o *Block) OpenDevice(ctx context.Context, mode string, options map[string]dbus.Variant) (fd dbus.UnixFD, err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".OpenDevice", 0, mode, options).Store(&fd)
	return
}

// Rescan calls org.freedesktop.UDisks2.Block.Rescan method.
func (o *Block) Rescan(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceBlock+".Rescan", 0, options).Store()
	return
}

// GetDevice gets org.freedesktop.UDisks2.Block.Device property.
func (o *Block) GetDevice(ctx context.Context) (device []byte, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "Device").Store(&device)
	return
}

// GetPreferredDevice gets org.freedesktop.UDisks2.Block.PreferredDevice property.
func (o *Block) GetPreferredDevice(ctx context.Context) (preferredDevice []byte, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "PreferredDevice").Store(&preferredDevice)
	return
}

// GetSymlinks gets org.freedesktop.UDisks2.Block.Symlinks property.
func (o *Block) GetSymlinks(ctx context.Context) (symlinks [][]byte, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "Symlinks").Store(&symlinks)
	return
}

// GetDeviceNumber gets org.freedesktop.UDisks2.Block.DeviceNumber property.
func (o *Block) GetDeviceNumber(ctx context.Context) (deviceNumber uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "DeviceNumber").Store(&deviceNumber)
	return
}

// GetId gets org.freedesktop.UDisks2.Block.Id property.
func (o *Block) GetId(ctx context.Context) (id string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "Id").Store(&id)
	return
}

// GetSize gets org.freedesktop.UDisks2.Block.Size property.
func (o *Block) GetSize(ctx context.Context) (size uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "Size").Store(&size)
	return
}

// GetReadOnly gets org.freedesktop.UDisks2.Block.ReadOnly property.
func (o *Block) GetReadOnly(ctx context.Context) (readOnly bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "ReadOnly").Store(&readOnly)
	return
}

// GetDrive gets org.freedesktop.UDisks2.Block.Drive property.
func (o *Block) GetDrive(ctx context.Context) (drive dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "Drive").Store(&drive)
	return
}

// GetMDRaid gets org.freedesktop.UDisks2.Block.MDRaid property.
func (o *Block) GetMDRaid(ctx context.Context) (mDRaid dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "MDRaid").Store(&mDRaid)
	return
}

// GetMDRaidMember gets org.freedesktop.UDisks2.Block.MDRaidMember property.
func (o *Block) GetMDRaidMember(ctx context.Context) (mDRaidMember dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "MDRaidMember").Store(&mDRaidMember)
	return
}

// GetIdUsage gets org.freedesktop.UDisks2.Block.IdUsage property.
func (o *Block) GetIdUsage(ctx context.Context) (idUsage string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "IdUsage").Store(&idUsage)
	return
}

// GetIdType gets org.freedesktop.UDisks2.Block.IdType property.
func (o *Block) GetIdType(ctx context.Context) (idType string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "IdType").Store(&idType)
	return
}

// GetIdVersion gets org.freedesktop.UDisks2.Block.IdVersion property.
func (o *Block) GetIdVersion(ctx context.Context) (idVersion string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "IdVersion").Store(&idVersion)
	return
}

// GetIdLabel gets org.freedesktop.UDisks2.Block.IdLabel property.
func (o *Block) GetIdLabel(ctx context.Context) (idLabel string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "IdLabel").Store(&idLabel)
	return
}

// GetIdUUID gets org.freedesktop.UDisks2.Block.IdUUID property.
func (o *Block) GetIdUUID(ctx context.Context) (idUUID string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "IdUUID").Store(&idUUID)
	return
}

// GetConfiguration gets org.freedesktop.UDisks2.Block.Configuration property.
func (o *Block) GetConfiguration(ctx context.Context) (configuration []struct {
	V0 string
	V1 map[string]dbus.Variant
}, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "Configuration").Store(&configuration)
	return
}

// GetCryptoBackingDevice gets org.freedesktop.UDisks2.Block.CryptoBackingDevice property.
func (o *Block) GetCryptoBackingDevice(ctx context.Context) (cryptoBackingDevice dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "CryptoBackingDevice").Store(&cryptoBackingDevice)
	return
}

// GetHintPartitionable gets org.freedesktop.UDisks2.Block.HintPartitionable property.
func (o *Block) GetHintPartitionable(ctx context.Context) (hintPartitionable bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintPartitionable").Store(&hintPartitionable)
	return
}

// GetHintSystem gets org.freedesktop.UDisks2.Block.HintSystem property.
func (o *Block) GetHintSystem(ctx context.Context) (hintSystem bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintSystem").Store(&hintSystem)
	return
}

// GetHintIgnore gets org.freedesktop.UDisks2.Block.HintIgnore property.
func (o *Block) GetHintIgnore(ctx context.Context) (hintIgnore bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintIgnore").Store(&hintIgnore)
	return
}

// GetHintAuto gets org.freedesktop.UDisks2.Block.HintAuto property.
func (o *Block) GetHintAuto(ctx context.Context) (hintAuto bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintAuto").Store(&hintAuto)
	return
}

// GetHintName gets org.freedesktop.UDisks2.Block.HintName property.
func (o *Block) GetHintName(ctx context.Context) (hintName string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintName").Store(&hintName)
	return
}

// GetHintIconName gets org.freedesktop.UDisks2.Block.HintIconName property.
func (o *Block) GetHintIconName(ctx context.Context) (hintIconName string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintIconName").Store(&hintIconName)
	return
}

// GetHintSymbolicIconName gets org.freedesktop.UDisks2.Block.HintSymbolicIconName property.
func (o *Block) GetHintSymbolicIconName(ctx context.Context) (hintSymbolicIconName string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "HintSymbolicIconName").Store(&hintSymbolicIconName)
	return
}

// GetUserspaceMountOptions gets org.freedesktop.UDisks2.Block.UserspaceMountOptions property.
func (o *Block) GetUserspaceMountOptions(ctx context.Context) (userspaceMountOptions []string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceBlock, "UserspaceMountOptions").Store(&userspaceMountOptions)
	return
}

// NewPartitionTable creates and allocates org.freedesktop.UDisks2.PartitionTable.
func NewPartitionTable(object dbus.BusObject) *PartitionTable {
	return &PartitionTable{object}
}

// PartitionTable implements org.freedesktop.UDisks2.PartitionTable D-Bus interface.
type PartitionTable struct {
	object dbus.BusObject
}

// CreatePartition calls org.freedesktop.UDisks2.PartitionTable.CreatePartition method.
func (o *PartitionTable) CreatePartition(ctx context.Context, offset uint64, size uint64, inType string, name string, options map[string]dbus.Variant) (createdPartition dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfacePartitionTable+".CreatePartition", 0, offset, size, inType, name, options).Store(&createdPartition)
	return
}

// CreatePartitionAndFormat calls org.freedesktop.UDisks2.PartitionTable.CreatePartitionAndFormat method.
func (o *PartitionTable) CreatePartitionAndFormat(ctx context.Context, offset uint64, size uint64, inType string, name string, options map[string]dbus.Variant, formatType string, formatOptions map[string]dbus.Variant) (createdPartition dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfacePartitionTable+".CreatePartitionAndFormat", 0, offset, size, inType, name, options, formatType, formatOptions).Store(&createdPartition)
	return
}

// GetPartitions gets org.freedesktop.UDisks2.PartitionTable.Partitions property.
func (o *PartitionTable) GetPartitions(ctx context.Context) (partitions []dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartitionTable, "Partitions").Store(&partitions)
	return
}

// GetType gets org.freedesktop.UDisks2.PartitionTable.Type property.
func (o *PartitionTable) GetType(ctx context.Context) (vType string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartitionTable, "Type").Store(&vType)
	return
}

// NewPartition creates and allocates org.freedesktop.UDisks2.Partition.
func NewPartition(object dbus.BusObject) *Partition {
	return &Partition{object}
}

// Partition implements org.freedesktop.UDisks2.Partition D-Bus interface.
type Partition struct {
	object dbus.BusObject
}

// SetType calls org.freedesktop.UDisks2.Partition.SetType method.
func (o *Partition) SetType(ctx context.Context, inType string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfacePartition+".SetType", 0, inType, options).Store()
	return
}

// SetName calls org.freedesktop.UDisks2.Partition.SetName method.
func (o *Partition) SetName(ctx context.Context, name string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfacePartition+".SetName", 0, name, options).Store()
	return
}

// SetFlags calls org.freedesktop.UDisks2.Partition.SetFlags method.
func (o *Partition) SetFlags(ctx context.Context, flags uint64, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfacePartition+".SetFlags", 0, flags, options).Store()
	return
}

// Resize calls org.freedesktop.UDisks2.Partition.Resize method.
func (o *Partition) Resize(ctx context.Context, size uint64, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfacePartition+".Resize", 0, size, options).Store()
	return
}

// Delete calls org.freedesktop.UDisks2.Partition.Delete method.
func (o *Partition) Delete(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfacePartition+".Delete", 0, options).Store()
	return
}

// GetNumber gets org.freedesktop.UDisks2.Partition.Number property.
func (o *Partition) GetNumber(ctx context.Context) (number uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Number").Store(&number)
	return
}

// GetType gets org.freedesktop.UDisks2.Partition.Type property.
func (o *Partition) GetType(ctx context.Context) (vType string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Type").Store(&vType)
	return
}

// GetFlags gets org.freedesktop.UDisks2.Partition.Flags property.
func (o *Partition) GetFlags(ctx context.Context) (flags uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Flags").Store(&flags)
	return
}

// GetOffset gets org.freedesktop.UDisks2.Partition.Offset property.
func (o *Partition) GetOffset(ctx context.Context) (offset uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Offset").Store(&offset)
	return
}

// GetSize gets org.freedesktop.UDisks2.Partition.Size property.
func (o *Partition) GetSize(ctx context.Context) (size uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Size").Store(&size)
	return
}

// GetName gets org.freedesktop.UDisks2.Partition.Name property.
func (o *Partition) GetName(ctx context.Context) (name string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Name").Store(&name)
	return
}

// GetUUID gets org.freedesktop.UDisks2.Partition.UUID property.
func (o *Partition) GetUUID(ctx context.Context) (uUID string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "UUID").Store(&uUID)
	return
}

// GetTable gets org.freedesktop.UDisks2.Partition.Table property.
func (o *Partition) GetTable(ctx context.Context) (table dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "Table").Store(&table)
	return
}

// GetIsContainer gets org.freedesktop.UDisks2.Partition.IsContainer property.
func (o *Partition) GetIsContainer(ctx context.Context) (isContainer bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "IsContainer").Store(&isContainer)
	return
}

// GetIsContained gets org.freedesktop.UDisks2.Partition.IsContained property.
func (o *Partition) GetIsContained(ctx context.Context) (isContained bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfacePartition, "IsContained").Store(&isContained)
	return
}

// NewFilesystem creates and allocates org.freedesktop.UDisks2.Filesystem.
func NewFilesystem(object dbus.BusObject) *Filesystem {
	return &Filesystem{object}
}

// Filesystem implements org.freedesktop.UDisks2.Filesystem D-Bus interface.
type Filesystem struct {
	object dbus.BusObject
}

// SetLabel calls org.freedesktop.UDisks2.Filesystem.SetLabel method.
func (o *Filesystem) SetLabel(ctx context.Context, label string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".SetLabel", 0, label, options).Store()
	return
}

// Mount calls org.freedesktop.UDisks2.Filesystem.Mount method.
func (o *Filesystem) Mount(ctx context.Context, options map[string]dbus.Variant) (mountPath string, err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".Mount", 0, options).Store(&mountPath)
	return
}

// Unmount calls org.freedesktop.UDisks2.Filesystem.Unmount method.
func (o *Filesystem) Unmount(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".Unmount", 0, options).Store()
	return
}

// Resize calls org.freedesktop.UDisks2.Filesystem.Resize method.
func (o *Filesystem) Resize(ctx context.Context, size uint64, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".Resize", 0, size, options).Store()
	return
}

// Check calls org.freedesktop.UDisks2.Filesystem.Check method.
func (o *Filesystem) Check(ctx context.Context, options map[string]dbus.Variant) (consistent bool, err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".Check", 0, options).Store(&consistent)
	return
}

// Repair calls org.freedesktop.UDisks2.Filesystem.Repair method.
func (o *Filesystem) Repair(ctx context.Context, options map[string]dbus.Variant) (repaired bool, err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".Repair", 0, options).Store(&repaired)
	return
}

// TakeOwnership calls org.freedesktop.UDisks2.Filesystem.TakeOwnership method.
func (o *Filesystem) TakeOwnership(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceFilesystem+".TakeOwnership", 0, options).Store()
	return
}

// GetMountPoints gets org.freedesktop.UDisks2.Filesystem.MountPoints property.
func (o *Filesystem) GetMountPoints(ctx context.Context) (mountPoints [][]byte, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceFilesystem, "MountPoints").Store(&mountPoints)
	return
}

// GetSize gets org.freedesktop.UDisks2.Filesystem.Size property.
func (o *Filesystem) GetSize(ctx context.Context) (size uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceFilesystem, "Size").Store(&size)
	return
}

// NewSwapspace creates and allocates org.freedesktop.UDisks2.Swapspace.
func NewSwapspace(object dbus.BusObject) *Swapspace {
	return &Swapspace{object}
}

// Swapspace implements org.freedesktop.UDisks2.Swapspace D-Bus interface.
type Swapspace struct {
	object dbus.BusObject
}

// Start calls org.freedesktop.UDisks2.Swapspace.Start method.
func (o *Swapspace) Start(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceSwapspace+".Start", 0, options).Store()
	return
}

// Stop calls org.freedesktop.UDisks2.Swapspace.Stop method.
func (o *Swapspace) Stop(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceSwapspace+".Stop", 0, options).Store()
	return
}

// SetLabel calls org.freedesktop.UDisks2.Swapspace.SetLabel method.
func (o *Swapspace) SetLabel(ctx context.Context, label string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceSwapspace+".SetLabel", 0, label, options).Store()
	return
}

// GetActive gets org.freedesktop.UDisks2.Swapspace.Active property.
func (o *Swapspace) GetActive(ctx context.Context) (active bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceSwapspace, "Active").Store(&active)
	return
}

// NewEncrypted creates and allocates org.freedesktop.UDisks2.Encrypted.
func NewEncrypted(object dbus.BusObject) *Encrypted {
	return &Encrypted{object}
}

// Encrypted implements org.freedesktop.UDisks2.Encrypted D-Bus interface.
type Encrypted struct {
	object dbus.BusObject
}

// Unlock calls org.freedesktop.UDisks2.Encrypted.Unlock method.
func (o *Encrypted) Unlock(ctx context.Context, passphrase string, options map[string]dbus.Variant) (cleartextDevice dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, InterfaceEncrypted+".Unlock", 0, passphrase, options).Store(&cleartextDevice)
	return
}

// Lock calls org.freedesktop.UDisks2.Encrypted.Lock method.
func (o *Encrypted) Lock(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceEncrypted+".Lock", 0, options).Store()
	return
}

// ChangePassphrase calls org.freedesktop.UDisks2.Encrypted.ChangePassphrase method.
func (o *Encrypted) ChangePassphrase(ctx context.Context, passphrase string, newPassphrase string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceEncrypted+".ChangePassphrase", 0, passphrase, newPassphrase, options).Store()
	return
}

// Resize calls org.freedesktop.UDisks2.Encrypted.Resize method.
func (o *Encrypted) Resize(ctx context.Context, size uint64, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceEncrypted+".Resize", 0, size, options).Store()
	return
}

// GetChildConfiguration gets org.freedesktop.UDisks2.Encrypted.ChildConfiguration property.
func (o *Encrypted) GetChildConfiguration(ctx context.Context) (childConfiguration []struct {
	V0 string
	V1 map[string]dbus.Variant
}, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceEncrypted, "ChildConfiguration").Store(&childConfiguration)
	return
}

// GetHintEncryptionType gets org.freedesktop.UDisks2.Encrypted.HintEncryptionType property.
func (o *Encrypted) GetHintEncryptionType(ctx context.Context) (hintEncryptionType string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceEncrypted, "HintEncryptionType").Store(&hintEncryptionType)
	return
}

// GetMetadataSize gets org.freedesktop.UDisks2.Encrypted.MetadataSize property.
func (o *Encrypted) GetMetadataSize(ctx context.Context) (metadataSize uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceEncrypted, "MetadataSize").Store(&metadataSize)
	return
}

// GetCleartextDevice gets org.freedesktop.UDisks2.Encrypted.CleartextDevice property.
func (o *Encrypted) GetCleartextDevice(ctx context.Context) (cleartextDevice dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceEncrypted, "CleartextDevice").Store(&cleartextDevice)
	return
}

// NewLoop creates and allocates org.freedesktop.UDisks2.Loop.
func NewLoop(object dbus.BusObject) *Loop {
	return &Loop{object}
}

// Loop implements org.freedesktop.UDisks2.Loop D-Bus interface.
type Loop struct {
	object dbus.BusObject
}

// Delete calls org.freedesktop.UDisks2.Loop.Delete method.
func (o *Loop) Delete(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceLoop+".Delete", 0, options).Store()
	return
}

// SetAutoclear calls org.freedesktop.UDisks2.Loop.SetAutoclear method.
func (o *Loop) SetAutoclear(ctx context.Context, value bool, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceLoop+".SetAutoclear", 0, value, options).Store()
	return
}

// GetBackingFile gets org.freedesktop.UDisks2.Loop.BackingFile property.
func (o *Loop) GetBackingFile(ctx context.Context) (backingFile []byte, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceLoop, "BackingFile").Store(&backingFile)
	return
}

// GetAutoclear gets org.freedesktop.UDisks2.Loop.Autoclear property.
func (o *Loop) GetAutoclear(ctx context.Context) (autoclear bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceLoop, "Autoclear").Store(&autoclear)
	return
}

// GetSetupByUID gets org.freedesktop.UDisks2.Loop.SetupByUID property.
func (o *Loop) GetSetupByUID(ctx context.Context) (setupByUID uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceLoop, "SetupByUID").Store(&setupByUID)
	return
}

// NewMDRaid creates and allocates org.freedesktop.UDisks2.MDRaid.
func NewMDRaid(object dbus.BusObject) *MDRaid {
	return &MDRaid{object}
}

// MDRaid implements org.freedesktop.UDisks2.MDRaid D-Bus interface.
type MDRaid struct {
	object dbus.BusObject
}

// Start calls org.freedesktop.UDisks2.MDRaid.Start method.
func (o *MDRaid) Start(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".Start", 0, options).Store()
	return
}

// Stop calls org.freedesktop.UDisks2.MDRaid.Stop method.
func (o *MDRaid) Stop(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".Stop", 0, options).Store()
	return
}

// RemoveDevice calls org.freedesktop.UDisks2.MDRaid.RemoveDevice method.
func (o *MDRaid) RemoveDevice(ctx context.Context, device dbus.ObjectPath, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".RemoveDevice", 0, device, options).Store()
	return
}

// AddDevice calls org.freedesktop.UDisks2.MDRaid.AddDevice method.
func (o *MDRaid) AddDevice(ctx context.Context, device dbus.ObjectPath, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".AddDevice", 0, device, options).Store()
	return
}

// SetBitmapLocation calls org.freedesktop.UDisks2.MDRaid.SetBitmapLocation method.
func (o *MDRaid) SetBitmapLocation(ctx context.Context, value []byte, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".SetBitmapLocation", 0, value, options).Store()
	return
}

// RequestSyncAction calls org.freedesktop.UDisks2.MDRaid.RequestSyncAction method.
func (o *MDRaid) RequestSyncAction(ctx context.Context, syncAction string, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".RequestSyncAction", 0, syncAction, options).Store()
	return
}

// Delete calls org.freedesktop.UDisks2.MDRaid.Delete method.
func (o *MDRaid) Delete(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceMDRaid+".Delete", 0, options).Store()
	return
}

// GetUUID gets org.freedesktop.UDisks2.MDRaid.UUID property.
func (o *MDRaid) GetUUID(ctx context.Context) (uUID string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "UUID").Store(&uUID)
	return
}

// GetName gets org.freedesktop.UDisks2.MDRaid.Name property.
func (o *MDRaid) GetName(ctx context.Context) (name string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "Name").Store(&name)
	return
}

// GetLevel gets org.freedesktop.UDisks2.MDRaid.Level property.
func (o *MDRaid) GetLevel(ctx context.Context) (level string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "Level").Store(&level)
	return
}

// GetNumDevices gets org.freedesktop.UDisks2.MDRaid.NumDevices property.
func (o *MDRaid) GetNumDevices(ctx context.Context) (numDevices uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "NumDevices").Store(&numDevices)
	return
}

// GetSize gets org.freedesktop.UDisks2.MDRaid.Size property.
func (o *MDRaid) GetSize(ctx context.Context) (size uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "Size").Store(&size)
	return
}

// GetSyncAction gets org.freedesktop.UDisks2.MDRaid.SyncAction property.
func (o *MDRaid) GetSyncAction(ctx context.Context) (syncAction string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "SyncAction").Store(&syncAction)
	return
}

// GetSyncCompleted gets org.freedesktop.UDisks2.MDRaid.SyncCompleted property.
func (o *MDRaid) GetSyncCompleted(ctx context.Context) (syncCompleted float64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "SyncCompleted").Store(&syncCompleted)
	return
}

// GetSyncRate gets org.freedesktop.UDisks2.MDRaid.SyncRate property.
func (o *MDRaid) GetSyncRate(ctx context.Context) (syncRate uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "SyncRate").Store(&syncRate)
	return
}

// GetSyncRemainingTime gets org.freedesktop.UDisks2.MDRaid.SyncRemainingTime property.
func (o *MDRaid) GetSyncRemainingTime(ctx context.Context) (syncRemainingTime uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "SyncRemainingTime").Store(&syncRemainingTime)
	return
}

// GetDegraded gets org.freedesktop.UDisks2.MDRaid.Degraded property.
func (o *MDRaid) GetDegraded(ctx context.Context) (degraded uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "Degraded").Store(&degraded)
	return
}

// GetBitmapLocation gets org.freedesktop.UDisks2.MDRaid.BitmapLocation property.
func (o *MDRaid) GetBitmapLocation(ctx context.Context) (bitmapLocation []byte, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "BitmapLocation").Store(&bitmapLocation)
	return
}

// GetChunkSize gets org.freedesktop.UDisks2.MDRaid.ChunkSize property.
func (o *MDRaid) GetChunkSize(ctx context.Context) (chunkSize uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "ChunkSize").Store(&chunkSize)
	return
}

// GetActiveDevices gets org.freedesktop.UDisks2.MDRaid.ActiveDevices property.
func (o *MDRaid) GetActiveDevices(ctx context.Context) (activeDevices []struct {
	V0 dbus.ObjectPath
	V1 int32
	V2 []string
	V3 uint64
	V4 map[string]dbus.Variant
}, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "ActiveDevices").Store(&activeDevices)
	return
}

// GetChildConfiguration gets org.freedesktop.UDisks2.MDRaid.ChildConfiguration property.
func (o *MDRaid) GetChildConfiguration(ctx context.Context) (childConfiguration []struct {
	V0 string
	V1 map[string]dbus.Variant
}, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "ChildConfiguration").Store(&childConfiguration)
	return
}

// GetRunning gets org.freedesktop.UDisks2.MDRaid.Running property.
func (o *MDRaid) GetRunning(ctx context.Context) (running bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceMDRaid, "Running").Store(&running)
	return
}

// NewJob creates and allocates org.freedesktop.UDisks2.Job.
func NewJob(object dbus.BusObject) *Job {
	return &Job{object}
}

// Job implements org.freedesktop.UDisks2.Job D-Bus interface.
type Job struct {
	object dbus.BusObject
}

// Cancel calls org.freedesktop.UDisks2.Job.Cancel method.
func (o *Job) Cancel(ctx context.Context, options map[string]dbus.Variant) (err error) {
	err = o.object.CallWithContext(ctx, InterfaceJob+".Cancel", 0, options).Store()
	return
}

// GetOperation gets org.freedesktop.UDisks2.Job.Operation property.
func (o *Job) GetOperation(ctx context.Context) (operation string, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "Operation").Store(&operation)
	return
}

// GetProgress gets org.freedesktop.UDisks2.Job.Progress property.
func (o *Job) GetProgress(ctx context.Context) (progress float64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "Progress").Store(&progress)
	return
}

// GetProgressValid gets org.freedesktop.UDisks2.Job.ProgressValid property.
func (o *Job) GetProgressValid(ctx context.Context) (progressValid bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "ProgressValid").Store(&progressValid)
	return
}

// GetBytes gets org.freedesktop.UDisks2.Job.Bytes property.
func (o *Job) GetBytes(ctx context.Context) (bytes uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "Bytes").Store(&bytes)
	return
}

// GetRate gets org.freedesktop.UDisks2.Job.Rate property.
func (o *Job) GetRate(ctx context.Context) (rate uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "Rate").Store(&rate)
	return
}

// GetStartTime gets org.freedesktop.UDisks2.Job.StartTime property.
func (o *Job) GetStartTime(ctx context.Context) (startTime uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "StartTime").Store(&startTime)
	return
}

// GetExpectedEndTime gets org.freedesktop.UDisks2.Job.ExpectedEndTime property.
func (o *Job) GetExpectedEndTime(ctx context.Context) (expectedEndTime uint64, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "ExpectedEndTime").Store(&expectedEndTime)
	return
}

// GetObjects gets org.freedesktop.UDisks2.Job.Objects property.
func (o *Job) GetObjects(ctx context.Context) (objects []dbus.ObjectPath, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "Objects").Store(&objects)
	return
}

// GetStartedByUID gets org.freedesktop.UDisks2.Job.StartedByUID property.
func (o *Job) GetStartedByUID(ctx context.Context) (startedByUID uint32, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "StartedByUID").Store(&startedByUID)
	return
}

// GetCancelable gets org.freedesktop.UDisks2.Job.Cancelable property.
func (o *Job) GetCancelable(ctx context.Context) (cancelable bool, err error) {
	err = o.object.CallWithContext(ctx, "org.freedesktop.DBus.Properties.Get", 0, InterfaceJob, "Cancelable").Store(&cancelable)
	return
}

// JobCompletedSignal represents org.freedesktop.UDisks2.Job.Completed signal.
type JobCompletedSignal struct {
	sender string
	Path   dbus.ObjectPath
	Body   *JobCompletedSignalBody
}

// Name returns the signal's name.
func (s *JobCompletedSignal) Name() string {
	return "Completed"
}

// Interface returns the signal's interface.
func (s *JobCompletedSignal) Interface() string {
	return InterfaceJob
}

// Sender returns the signal's sender unique name.
func (s *JobCompletedSignal) Sender() string {
	return s.sender
}

func (s *JobCompletedSignal) path() dbus.ObjectPath {
	return s.Path
}

func (s *JobCompletedSignal) values() []interface{} {
	return []interface{}{s.Body.Success, s.Body.Message}
}

// JobCompletedSignalBody is body container.
type JobCompletedSignalBody struct {
	Success bool
	Message string
}
0707010000002E000081A400000000000000000000000164F6FC38000004CF000000000000000000000000000000000000003100000000homeassistant-os-agent-1.6.0/udisks2/apiutils.gopackage udisks2

import (
	"context"
	"fmt"
	"strings"

"github.com/godbus/dbus/v5"
)

var noOptions = map[string]dbus.Variant{}

func (o *Block) GetDeviceString(ctx context.Context) (*string, error) {

device, err := o.GetDevice(ctx)
	if err != nil {
		return nil, err
	}

s := strings.Trim(string(device), "\x00")
	return &s, nil
}

func (f *Filesystem) GetMountPointsString(ctx context.Context) ([]string, error) {
	dataMountPoints, err := f.GetMountPoints(ctx)
	if err != nil {
		return nil, err
	}

dataMountPointsString := make([]string, len(dataMountPoints))
	for i, ba := range dataMountPoints {
		s := strings.Trim(string(ba), "\x00")
		dataMountPointsString[i] = s
	}

return dataMountPointsString, nil
}

func (m *Manager) ResolveDeviceFromLabel(label string) (*dbus.ObjectPath, error) {
	devspec := map[string]dbus.Variant{"label": dbus.MakeVariant(label)}
	blockObjects, err := m.ResolveDevice(context.Background(), devspec, noOptions)

if err != nil {
		return nil, err
	}
	if len(blockObjects) != 1 {
		return nil, fmt.Errorf("Expected single block device with file system label \"%s\", found %d", label, len(blockObjects))
	}

/* Get Partition object of the data partition */
	return &blockObjects[0], nil
}
0707010000002F000081A400000000000000000000000164F6FC3800000E05000000000000000000000000000000000000002F00000000homeassistant-os-agent-1.6.0/udisks2/helper.gopackage udisks2

import (
	"context"
	"fmt"

"github.com/godbus/dbus/v5"

logging "github.com/home-assistant/os-agent/utils/log"
)

type UDisks2Helper struct {
	conn    *dbus.Conn
	manager *Manager
}

func NewUDisks2(conn *dbus.Conn) UDisks2Helper {
	busObj := conn.Object("org.freedesktop.UDisks2", "/org/freedesktop/UDisks2/Manager")
	manager := NewManager(busObj)

d := UDisks2Helper{
		conn:    conn,
		manager: manager,
	}

return d
}

func (u UDisks2Helper) GetBusObjectFromLabel(label string) (dbus.BusObject, error) {

busObject, err := u.manager.ResolveDeviceFromLabel(label)
	if err != nil {
		return nil, err
	}

return u.conn.Object("org.freedesktop.UDisks2", *busObject), nil
}

func (u UDisks2Helper) GetRootDeviceFromLabel(label string) (*string, error) {

busObject, err := u.manager.ResolveDeviceFromLabel(label)
	if err != nil {
		return nil, err
	}

busObjectBlock := u.conn.Object("org.freedesktop.UDisks2", *busObject)
	partition := NewPartition(busObjectBlock)
	table, err := partition.GetTable(context.Background())
	if err != nil {
		return nil, err
	}

/* Get Block device of partition table */
	busObjectParentBlock := u.conn.Object("org.freedesktop.UDisks2", table)
	parentBlock := NewBlock(busObjectParentBlock)

return parentBlock.GetDeviceString(context.Background())
}

func (u UDisks2Helper) FormatPartition(blockObjectPath dbus.BusObject, fsType string, label string) error {
	parentBlock := NewBlock(blockObjectPath)
	formatOptions := map[string]dbus.Variant{"label": dbus.MakeVariant(label)}
	err := parentBlock.Format(context.Background(), fsType, formatOptions)
	if err != nil {
		return err
	}

return nil
}

func (u UDisks2Helper) FormatPartitionFromDevicePath(devicePath string, fsType string, label string) error {
	devspec := map[string]dbus.Variant{"path": dbus.MakeVariant(devicePath)}
	blockObjects, err := u.manager.ResolveDevice(context.Background(), devspec, noOptions)
	if err != nil {
		return err
	}
	if len(blockObjects) != 1 {
		return fmt.Errorf("Expected single block device with device path \"%s\", found %d", devicePath, len(blockObjects))
	}

logging.Info.Printf("Formatting block device %s with file system \"%s\".", devicePath, fsType)
	blockObjectPath := blockObjects[0]
	busObjectBlock := u.conn.Object("org.freedesktop.UDisks2", blockObjectPath)

err = u.FormatPartition(busObjectBlock, fsType, label)
	if err != nil {
		return err
	}

logging.Info.Printf("Successfully formatted block device %s.", devicePath)

return nil
}

func (u UDisks2Helper) PartitionDeviceWithSinglePartition(devicePath string, uuid string, name string) error {
	devspec := map[string]dbus.Variant{"path": dbus.MakeVariant(devicePath)}
	blockObjects, err := u.manager.ResolveDevice(context.Background(), devspec, noOptions)
	if err != nil {
		return err
	}
	if len(blockObjects) != 1 {
		return fmt.Errorf("Expected single block device with device path \"%s\", found %d", devicePath, len(blockObjects))
	}

blockObjectPath := blockObjects[0]
	logging.Info.Printf("Formatting device %s", devicePath)

busObjectParentBlock := u.conn.Object("org.freedesktop.UDisks2", blockObjectPath)
	parentBlock := NewBlock(busObjectParentBlock)
	err = parentBlock.Format(context.Background(), "gpt", noOptions)
	if err != nil {
		return err
	}

parentPartitionTable := NewPartitionTable(busObjectParentBlock)
	createdPartition, err :=
		parentPartitionTable.CreatePartition(context.Background(), 0, 0,
			uuid, name, noOptions)
	if err != nil {
		return err
	}
	logging.Info.Printf("New partition D-Bus object %s.", createdPartition)

return nil
}
07070100000030000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002300000000homeassistant-os-agent-1.6.0/utils07070100000031000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002C00000000homeassistant-os-agent-1.6.0/utils/bootfile07070100000032000081A400000000000000000000000164F6FC3800000AC5000000000000000000000000000000000000003600000000homeassistant-os-agent-1.6.0/utils/bootfile/editor.gopackage bootfile

import (
	"bufio"
	"os"
	"strings"

logging "github.com/home-assistant/os-agent/utils/log"

"github.com/natefinch/atomic"
)

type Editor struct {
	FilePath  string
	Delimiter string
}

func (e Editor) ReadOption(optionName string, defaultValue string) (string, error) {
	// Read the options from the boot file
	file, err := os.Open(e.FilePath)
	if err != nil {
		logging.Error.Printf("Failed to open boot file %s: %s", e.FilePath, err)
		return defaultValue, err
	}
	defer file.Close()

// Scan over all lines
	fileScanner := bufio.NewScanner(file)
	fileScanner.Split(bufio.ScanLines)

for fileScanner.Scan() {
		line := fileScanner.Text()
		if strings.HasPrefix(line, optionName) {
			return strings.Replace(line, optionName+e.Delimiter, "", 1), nil
		}
	}

return defaultValue, nil
}

func (e Editor) DisableOption(optionName string) error {
	// Read the options from the boot file
	file, err := os.Open(e.FilePath)
	if err != nil {
		logging.Error.Printf("Failed to open boot file %s: %s", e.FilePath, err)
		return err
	}

// Scan over all lines
	fileScanner := bufio.NewScanner(file)
	fileScanner.Split(bufio.ScanLines)

var outLines []string
	for fileScanner.Scan() {
		line := fileScanner.Text()
		if strings.HasPrefix(line, optionName) {
			outLines = append(outLines, "#"+line)
		} else {
			outLines = append(outLines, line)
		}
	}
	file.Close()

// Write all lines back to boot config file
	return e.writeNewBootFile(outLines)
}

func (e Editor) SetOption(optionName string, value string) error {
	// Read the options from the boot file
	file, err := os.Open(e.FilePath)
	if err != nil {
		logging.Error.Printf("Failed to open boot file %s: %s", e.FilePath, err)
		return err
	}

// Scan over all lines
	fileScanner := bufio.NewScanner(file)
	fileScanner.Split(bufio.ScanLines)

var outLines []string
	var found bool = false
	for fileScanner.Scan() {
		line := fileScanner.Text()
		if strings.HasPrefix(line, optionName) || strings.HasPrefix(line, "#"+optionName) {
			if !found {
				outLines = append(outLines, optionName+e.Delimiter+value)
				found = true
			}
		} else {
			outLines = append(outLines, line)
		}
	}
	file.Close()

// No option found, add it
	if !found {
		outLines = append(outLines, optionName+e.Delimiter+value)
	}

// Write all lines back to boot config file
	return e.writeNewBootFile(outLines)
}

func (e Editor) writeNewBootFile(lines []string) error {
	// Write all lines back to boot config file
	raw := strings.Join(lines, "\n")
	if !strings.HasSuffix(raw, "\n") {
		raw += "\n"
	}
	reader := strings.NewReader(raw)

err := atomic.WriteFile(e.FilePath, reader)
	if err != nil {
		logging.Error.Printf("Failed to write boot file %s: %s", e.FilePath, err)
		return err
	}

return err
}
07070100000033000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002700000000homeassistant-os-agent-1.6.0/utils/led07070100000034000081A400000000000000000000000164F6FC38000002F0000000000000000000000000000000000000002E00000000homeassistant-os-agent-1.6.0/utils/led/led.gopackage led

import (
	"os"
	"path/filepath"
	"strings"
)

type LED struct {
	Name           string
	DefaultTrigger string
}

func (led LED) GetTrigger() (string, error) {
	ledTriggerFilePath := filepath.Join("/sys/class/leds/", led.Name, "trigger")
	ledTrigger, err := os.ReadFile(ledTriggerFilePath)
	if err != nil {
		return "", err
	}
	return strings.TrimSpace(string(ledTrigger)), err
}

func (led LED) SetTrigger(newState bool) error {
	ledTriggerFilePath := filepath.Join("/sys/class/leds/", led.Name, "trigger")
	var newTrigger []byte

if newState {
		newTrigger = []byte(led.DefaultTrigger)
	} else {
		newTrigger = []byte("none")
	}

err := os.WriteFile(ledTriggerFilePath, newTrigger, 0600)
	if err != nil {
		return err
	}

return nil
}
07070100000035000041ED00000000000000000000000264F6FC3800000000000000000000000000000000000000000000002700000000homeassistant-os-agent-1.6.0/utils/log07070100000036000081A400000000000000000000000164F6FC38000001D0000000000000000000000000000000000000002E00000000homeassistant-os-agent-1.6.0/utils/log/log.gopackage logging

import (
	"log"
	"os"
)

var (
	Info     *log.Logger
	Warning  *log.Logger
	Error    *log.Logger
	Critical *log.Logger
)

func init() {

Info = log.New(os.Stdout, "INFO: ", log.Ldate|log.Ltime|log.Lshortfile)
	Warning = log.New(os.Stdout, "WARNING: ", log.Ldate|log.Ltime|log.Lshortfile)
	Error = log.New(os.Stderr, "ERROR: ", log.Ldate|log.Ltime|log.Lshortfile)
	Critical = log.New(os.Stderr, "CRITICAL: ", log.Ldate|log.Ltime|log.Lshortfile)
}
07070100000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000B00000000TRAILER!!!266 blocks

Places

File homeassistant-os-agent-1.6.0.obscpio of Package homeassistant-os-agent (Revision 01cd765a993ca24270571eb6ad56087e)

Places