1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
// -*- Mode: Go; indent-tabs-mode: t -*-
/*
* Copyright (C) Canonical Ltd
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 3 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
package ldconfig
import (
"errors"
"github.com/snapcore/snapd/interfaces"
"github.com/snapcore/snapd/snap"
)
// Specification assists in collecting library directories associated with an
// interface.
//
// Unlike the Backend itself (which is stateless and non-persistent) this type
// holds internal state that is used by the ldconfig backend during the
// interface setup process.
type Specification struct {
// plugs is the list of plugs using ldconfig for the snap
plugs []string
// libDirs is the list of directories with libraries coming from
// different slots.
libDirs map[SnapSlot][]string
// slotSnapName and slotName are contextual information for the latest
// call to AddConnectedPlug.
slotSnapName, slotName string
}
// SnapSlot is the key for libDirs: directories are per snap slot.
type SnapSlot struct {
SnapName string
SlotName string
}
// Methods called by interfaces
// AddLibDirs adds dirs with libraries to the specification.
func (spec *Specification) AddLibDirs(dirs []string) error {
if spec.slotSnapName == "" || spec.slotName == "" {
return errors.New("internal error: no contextual information while calling AddLibDirs")
}
if spec.libDirs == nil {
spec.libDirs = make(map[SnapSlot][]string)
}
spec.libDirs[SnapSlot{SnapName: spec.slotSnapName, SlotName: spec.slotName}] = dirs
return nil
}
func (spec *Specification) LibDirs() map[SnapSlot][]string {
return spec.libDirs
}
func (spec *Specification) Plugs() []string {
return spec.plugs
}
// Implementation of methods required by interfaces.Specification
// ConnectedPlugCallback must be implemented as a minimum by users of this backend.
type ConnectedPlugCallback interface {
LdconfigConnectedPlug(spec *Specification, plug *interfaces.ConnectedPlug,
slot *interfaces.ConnectedSlot) error
}
func getConnectedPlugCallback(iface interfaces.Interface, instanceName string) (
ConnectedPlugCallback, error) {
if iface, ok := iface.(ConnectedPlugCallback); ok {
if !interfaces.IsTheSystemSnap(instanceName) {
return nil, errors.New("internal error: ldconfig plugs can be defined only by the system snap")
}
return iface, nil
}
return nil, nil
}
// AddConnectedPlug records ldconfig-specific side-effects of having a connected plug.
func (spec *Specification) AddConnectedPlug(iface interfaces.Interface, plug *interfaces.ConnectedPlug, slot *interfaces.ConnectedSlot) error {
connectedPlugCallback, err := getConnectedPlugCallback(iface, plug.Snap().InstanceName())
if err != nil {
return err
}
if connectedPlugCallback != nil {
// Set the contextual information
spec.slotSnapName = slot.Snap().SnapName()
spec.slotName = slot.Name()
return connectedPlugCallback.LdconfigConnectedPlug(spec, plug, slot)
}
return nil
}
// AddConnectedSlot records ldconfig-specific side-effects of having a connected slot.
func (spec *Specification) AddConnectedSlot(iface interfaces.Interface, plug *interfaces.ConnectedPlug, slot *interfaces.ConnectedSlot) error {
type definer interface {
LdconfigConnectedSlot(spec *Specification, plug *interfaces.ConnectedPlug,
slot *interfaces.ConnectedSlot) error
}
if iface, ok := iface.(definer); ok {
if !interfaces.IsTheSystemSnap(plug.Snap().InstanceName()) {
return errors.New("internal error: ldconfig plugs can be defined only by the system snap")
}
return iface.LdconfigConnectedSlot(spec, plug, slot)
}
return nil
}
// AddPermanentPlug records ldconfig-specific side-effects of having a plug.
func (spec *Specification) AddPermanentPlug(iface interfaces.Interface, plug *snap.PlugInfo) error {
// Note that ConnectedPlugCallback must be implemented, so we
// check for it instead of using LdconfigPermanentPlug.
connectedPlugCallback, err := getConnectedPlugCallback(iface, plug.Snap.InstanceName())
if err != nil {
return err
}
if connectedPlugCallback != nil {
// Keep track of interfaces using this backend on the consumer side
spec.plugs = append(spec.plugs, plug.Name)
}
type definer interface {
LdconfigPermanentPlug(spec *Specification, plug *snap.PlugInfo) error
}
if iface, ok := iface.(definer); ok {
if !interfaces.IsTheSystemSnap(plug.Snap.InstanceName()) {
return errors.New("internal error: ldconfig plugs can be defined only by the system snap")
}
return iface.LdconfigPermanentPlug(spec, plug)
}
return nil
}
// AddPermanentSlot records ldconfig-specific side-effects of having a slot.
func (spec *Specification) AddPermanentSlot(iface interfaces.Interface, slot *snap.SlotInfo) error {
type definer interface {
LdconfigPermanentSlot(spec *Specification, slot *snap.SlotInfo) error
}
if iface, ok := iface.(definer); ok {
return iface.LdconfigPermanentSlot(spec, slot)
}
return nil
}
|
