func (d *Daemon) verifyAdminPwd(password string) bool {
q := "SELECT value FROM config WHERE key=\"core.trust_password\""
value := ""
argIn := []interface{}{}
argOut := []interface{}{&value}
err := shared.DbQueryRowScan(d.db, q, argIn, argOut)
if err != nil || value == "" {
shared.Debugf("verifyAdminPwd: no password is set")
return false
}
buff, err := hex.DecodeString(value)
if err != nil {
shared.Debugf("hex decode failed")
return false
}
salt := buff[0:PW_SALT_BYTES]
hash, err := scrypt.Key([]byte(password), salt, 1<<14, 8, 1, PW_HASH_BYTES)
if err != nil {
shared.Debugf("failed to create hash to check")
return false
}
if !bytes.Equal(hash, buff[PW_SALT_BYTES:]) {
shared.Debugf("Bad password received")
return false
}
shared.Debugf("Verified the admin password")
return true
}
func (d *Daemon) hasPwd() bool {
q := "SELECT id FROM config WHERE key=\"core.trust_password\""
id := -1
argIn := []interface{}{}
argOut := []interface{}{&id}
err := shared.DbQueryRowScan(d.db, q, argIn, argOut)
return err == nil && id != -1
}
func getSchema(db *sql.DB) (v int) {
arg1 := []interface{}{}
arg2 := []interface{}{&v}
q := "SELECT max(version) FROM schema"
err := shared.DbQueryRowScan(db, q, arg1, arg2)
if err != nil {
return 0
}
return v
}
func (d *Daemon) dbGetimage(fp string) int {
q := `SELECT id FROM images WHERE fingerprint=?`
id := -1
arg1 := []interface{}{fp}
arg2 := []interface{}{&id}
err := shared.DbQueryRowScan(d.db, q, arg1, arg2)
if err != nil {
return -1
}
return id
}
// returns value, exists, error
// Check 'exists' before looking at value. if exists == false, value is meaningless.
func getServerConfigValue(d *Daemon, key string) (string, bool, error) {
var value string
q := "SELECT value from config where key=?"
arg1 := []interface{}{key}
arg2 := []interface{}{&value}
err := shared.DbQueryRowScan(d.db, q, arg1, arg2)
switch {
case err == sql.ErrNoRows:
return "", false, nil
case err != nil:
return "", false, err
default:
return value, true, nil
}
}
// Get an ImageBaseInfo object from the database.
// There can never be more than one image with a given fingerprint, as it is
// enforced by a UNIQUE constraint in the schema.
func dbImageGet(db *sql.DB, fingerprint string, public bool) (*shared.ImageBaseInfo, error) {
var err error
var create, expire, upload *time.Time // These hold the db-returned times
// The object we'll actually return
image := new(shared.ImageBaseInfo)
// These two humongous things will be filled by the call to DbQueryRowScan
inargs := []interface{}{fingerprint + "%"}
outfmt := []interface{}{&image.Id, &image.Fingerprint, &image.Filename,
&image.Size, &image.Public, &image.Architecture,
&create, &expire, &upload}
query := `
SELECT
id, fingerprint, filename, size, public, architecture,
creation_date, expiry_date, upload_date
FROM
images
WHERE fingerprint like ?`
if public {
query = query + " AND public=1"
}
err = shared.DbQueryRowScan(db, query, inargs, outfmt)
if err != nil {
return nil, err // Likely: there are no rows for this fingerprint
}
// Some of the dates can be nil in the DB, let's process them.
if create != nil {
image.CreationDate = create.Unix()
} else {
image.CreationDate = 0
}
if expire != nil {
image.ExpiryDate = expire.Unix()
} else {
image.ExpiryDate = 0
}
// The upload date is enforced by NOT NULL in the schema, so it can never be nil.
image.UploadDate = upload.Unix()
return image, nil
}
func doAliasGet(d *Daemon, name string, isTrustedClient bool) (shared.ImageAlias, error) {
q := `SELECT images.fingerprint, images_aliases.description
FROM images_aliases
INNER JOIN images
ON images_aliases.image_id=images.id
WHERE images_aliases.name=?`
if !isTrustedClient {
q = q + ` AND images.public=1`
}
var fingerprint, description string
arg1 := []interface{}{name}
arg2 := []interface{}{&fingerprint, &description}
err := shared.DbQueryRowScan(d.db, q, arg1, arg2)
if err != nil {
return shared.ImageAlias{}, err
}
return shared.ImageAlias{Name: fingerprint, Description: description}, nil
}
// Get an image's fingerprint for a given alias name.
func dbAliasGet(db *sql.DB, name string) (fingerprint string, err error) {
q := `
SELECT
fingerprint
FROM images AS i JOIN images_aliases AS a
ON a.image_id == i.id
WHERE name=?`
inargs := []interface{}{name}
outfmt := []interface{}{&fingerprint}
err = shared.DbQueryRowScan(db, q, inargs, outfmt)
if err == sql.ErrNoRows {
return "", NoSuchObjectError
}
if err != nil {
return "", err
}
return fingerprint, nil
}