tree 83a086f310851046f12cfd4c23ac69f872724dd8
parent 2b37e9f84372b5c98ef0ba114ce016953e47bc3c
author Markus Armbruster <armbru@redhat.com> 1605248638 +0100
committer Daniel P. Berrangé <berrange@redhat.com> 1605696695 +0000

authz-list-file: Improve an error message

When qauthz_list_file_load() rejects JSON values other than JSON
object with a rather confusing error message:

    $ echo 1 | qemu-system-x86_64 -nodefaults -S -display none  -object authz-list-file,id=authz0,filename=/dev/stdin
    qemu-system-x86_64: -object authz-list-file,id=authz0,filename=/dev/stdin: Invalid parameter type for 'obj', expected: dict

Improve to

    qemu-system-x86_64: -object authz-list-file,id=authz0,filename=/dev/stdin: File '/dev/stdin' must contain a JSON object

Signed-off-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
