package gokwallet import ( "github.com/godbus/dbus/v5" ) /* NewWallet returns a Wallet. It requires a RecurseOpts (you can use DefaultRecurseOpts, call NewRecurseOpts, or provide your own RecurseOpts struct). It also requires a WalletManager and wallet name. */ func NewWallet(wm *WalletManager, name string, recursion *RecurseOpts) (wallet *Wallet, err error) { if !wm.isInit { err = ErrNotInitialized return } wallet = &Wallet{ DbusObject: wm.DbusObject, Name: name, Folders: nil, Recurse: recursion, wm: wm, // handle: 0, isInit: false, } // TODO: remove this and leave to caller, since it might use PamOpen instead? Fail back to it? if err = wallet.walletCheck(); err != nil { return } if wallet.Recurse.All || wallet.Recurse.Folders { if err = wallet.Update(); err != nil { return } } wallet.isInit = true return } // Disconnect disconnects this Wallet from its parent WalletManager. func (w *Wallet) Disconnect() (err error) { var ok bool if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMDisconnectApp, 0, w.Name, w.wm.AppID, ).Store(&ok); err != nil { return } if !ok { err = ErrNoDisconnect } return } // DisconnectApplication disconnects this Wallet from a specified WalletManager/application (see Wallet.Connections). func (w *Wallet) DisconnectApplication(appName string) (err error) { var ok bool if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMDisconnectApp, 0, appName, w.wm.AppID, ).Store(&ok); err != nil { return } if !ok { err = ErrNoDisconnect } return } /* ChangePassword will change (or set) the password for a Wallet. Note that this *must* be done via the windowing layer. */ func (w *Wallet) ChangePassword() (err error) { var call *dbus.Call if err = w.walletCheck(); err != nil { return } call = w.Dbus.Call( DbusWMChangePassword, 0, w.Name, DefaultWindowID, w.wm.AppID, ) err = call.Err return } // Close closes a Wallet. func (w *Wallet) Close() (err error) { var rslt int32 if err = w.walletCheck(); err != nil { return } // Using a handler allows us to close access for this particular parent WalletManager. if err = w.Dbus.Call( DbusWMClose, 0, w.handle, false, w.wm.AppID, ).Store(&rslt); err != nil { return } err = resultCheck(rslt) return } // Connections lists the application names for connections to ("users of") this Wallet. func (w *Wallet) Connections() (connList []string, err error) { if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMUsers, 0, w.Name, ).Store(&connList); err != nil { return } return } // CreateFolder creates a new Folder in a Wallet. func (w *Wallet) CreateFolder(name string) (err error) { var ok bool if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMCreateFolder, 0, w.handle, name, w.wm.AppID, ).Store(&ok); err != nil { return } if !ok { err = ErrNoCreate } return } // Delete deletes a Wallet. func (w *Wallet) Delete() (err error) { var rslt int32 if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMDeleteWallet, 0, w.Name, ).Store(&rslt); err != nil { return } err = resultCheck(rslt) w = nil return } // FolderExists indicates if a Folder exists in a Wallet or not. func (w *Wallet) FolderExists(folderName string) (exists bool, err error) { var notExists bool // We don't need a walletcheck here since we don't need a handle. if err = w.Dbus.Call( DbusWMFolderNotExist, 0, w.Name, folderName, ).Store(¬Exists); err != nil { return } exists = !notExists return } /* ForceClose is like Close but will still close a Wallet even if currently in use by the WalletManager. (Despite the insinuation by the name, this should be a relatively safe operation). */ func (w *Wallet) ForceClose() (err error) { var rslt int32 if err = w.walletCheck(); err != nil { return } // Using a handler allows us to close access for this particular parent WalletManager. if err = w.Dbus.Call( DbusWMClose, 0, w.handle, true, w.wm.AppID, ).Store(&rslt); err != nil { return } err = resultCheck(rslt) return } // HasFolder indicates if a Wallet has a Folder in it named folderName. func (w *Wallet) HasFolder(folderName string) (hasFolder bool, err error) { if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMHasFolder, 0, w.handle, folderName, w.wm.AppID, ).Store(&hasFolder); err != nil { return } return } // IsOpen returns whether a Wallet is open ("unlocked") or not (as well as updates Wallet.IsOpen). func (w *Wallet) IsOpen() (isOpen bool, err error) { // We don't call walletcheck here because this method is called by a walletcheck. // We can call the same method with w.handle instead of w.Name. We don't have a handler yet though. if err = w.Dbus.Call( DbusWMIsOpen, 0, w.Name, ).Store(&w.IsUnlocked); err != nil { return } isOpen = w.IsUnlocked return } // ListFolders lists all Folder names in a Wallet. func (w *Wallet) ListFolders() (folderList []string, err error) { if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMFolderList, 0, w.handle, w.wm.AppID, ).Store(&folderList); err != nil { return } return } /* Open will open ("unlock") a Wallet. It will no-op if the Wallet is already open. */ func (w *Wallet) Open() (err error) { var handler *int32 if err = w.walletCheck(); err != nil { return } if !w.IsUnlocked { if err = w.Dbus.Call( DbusWMOpen, 0, ).Store(handler); err != nil { return } } if handler == nil { err = ErrOperationFailed return } else { w.handle = *handler } w.IsUnlocked = true return } /* RemoveFolder removes a Folder folderName from a Wallet. Note that this will also remove all WalletItems in the given Folder. */ func (w *Wallet) RemoveFolder(folderName string) (err error) { var success bool if err = w.walletCheck(); err != nil { return } if err = w.Dbus.Call( DbusWMRemoveFolder, 0, w.handle, folderName, w.wm.AppID, ).Store(&success); err != nil { return } if !success { err = ErrOperationFailed return } return } // Update fetches/updates all Folder objects in a Wallet. func (w *Wallet) Update() (err error) { var folderNames []string var errs []error = make([]error, 0) if err = w.walletCheck(); err != nil { return } if folderNames, err = w.ListFolders(); err != nil { return } w.Folders = make(map[string]*Folder) for _, fn := range folderNames { if w.Folders[fn], err = NewFolder(w, fn, w.Recurse); err != nil { errs = append(errs, err) err = nil continue } } if errs != nil && len(errs) > 0 { err = NewErrors(errs...) return } return } // walletCheck will check if a Wallet is (initialized and) opened and, if not, attempt to open it. func (w *Wallet) walletCheck() (err error) { if !w.isInit { err = ErrNotInitialized return } if _, err = w.IsOpen(); err != nil { return } if !w.IsUnlocked { if err = w.Open(); err != nil { return } } return }