1package overlay
2
3import (
4	"encoding/json"
5	"fmt"
6	"net"
7
8	"github.com/sirupsen/logrus"
9	"github.com/docker/libnetwork/datastore"
10	"github.com/docker/libnetwork/driverapi"
11	"github.com/docker/libnetwork/netutils"
12	"github.com/docker/libnetwork/ns"
13	"github.com/docker/libnetwork/types"
14)
15
16type endpointTable map[string]*endpoint
17
18const overlayEndpointPrefix = "overlay/endpoint"
19
20type endpoint struct {
21	id       string
22	nid      string
23	ifName   string
24	mac      net.HardwareAddr
25	addr     *net.IPNet
26	dbExists bool
27	dbIndex  uint64
28}
29
30func (n *network) endpoint(eid string) *endpoint {
31	n.Lock()
32	defer n.Unlock()
33
34	return n.endpoints[eid]
35}
36
37func (n *network) addEndpoint(ep *endpoint) {
38	n.Lock()
39	n.endpoints[ep.id] = ep
40	n.Unlock()
41}
42
43func (n *network) deleteEndpoint(eid string) {
44	n.Lock()
45	delete(n.endpoints, eid)
46	n.Unlock()
47}
48
49func (d *driver) CreateEndpoint(nid, eid string, ifInfo driverapi.InterfaceInfo,
50	epOptions map[string]interface{}) error {
51	var err error
52
53	if err = validateID(nid, eid); err != nil {
54		return err
55	}
56
57	// Since we perform lazy configuration make sure we try
58	// configuring the driver when we enter CreateEndpoint since
59	// CreateNetwork may not be called in every node.
60	if err := d.configure(); err != nil {
61		return err
62	}
63
64	n := d.network(nid)
65	if n == nil {
66		return fmt.Errorf("network id %q not found", nid)
67	}
68
69	ep := &endpoint{
70		id:   eid,
71		nid:  n.id,
72		addr: ifInfo.Address(),
73		mac:  ifInfo.MacAddress(),
74	}
75	if ep.addr == nil {
76		return fmt.Errorf("create endpoint was not passed interface IP address")
77	}
78
79	if s := n.getSubnetforIP(ep.addr); s == nil {
80		return fmt.Errorf("no matching subnet for IP %q in network %q", ep.addr, nid)
81	}
82
83	if ep.mac == nil {
84		ep.mac = netutils.GenerateMACFromIP(ep.addr.IP)
85		if err := ifInfo.SetMacAddress(ep.mac); err != nil {
86			return err
87		}
88	}
89
90	n.addEndpoint(ep)
91
92	if err := d.writeEndpointToStore(ep); err != nil {
93		return fmt.Errorf("failed to update overlay endpoint %s to local store: %v", ep.id[0:7], err)
94	}
95
96	return nil
97}
98
99func (d *driver) DeleteEndpoint(nid, eid string) error {
100	nlh := ns.NlHandle()
101
102	if err := validateID(nid, eid); err != nil {
103		return err
104	}
105
106	n := d.network(nid)
107	if n == nil {
108		return fmt.Errorf("network id %q not found", nid)
109	}
110
111	ep := n.endpoint(eid)
112	if ep == nil {
113		return fmt.Errorf("endpoint id %q not found", eid)
114	}
115
116	n.deleteEndpoint(eid)
117
118	if err := d.deleteEndpointFromStore(ep); err != nil {
119		logrus.Warnf("Failed to delete overlay endpoint %s from local store: %v", ep.id[0:7], err)
120	}
121
122	if ep.ifName == "" {
123		return nil
124	}
125
126	link, err := nlh.LinkByName(ep.ifName)
127	if err != nil {
128		logrus.Debugf("Failed to retrieve interface (%s)'s link on endpoint (%s) delete: %v", ep.ifName, ep.id, err)
129		return nil
130	}
131	if err := nlh.LinkDel(link); err != nil {
132		logrus.Debugf("Failed to delete interface (%s)'s link on endpoint (%s) delete: %v", ep.ifName, ep.id, err)
133	}
134
135	return nil
136}
137
138func (d *driver) EndpointOperInfo(nid, eid string) (map[string]interface{}, error) {
139	return make(map[string]interface{}, 0), nil
140}
141
142func (d *driver) deleteEndpointFromStore(e *endpoint) error {
143	if d.localStore == nil {
144		return fmt.Errorf("overlay local store not initialized, ep not deleted")
145	}
146
147	if err := d.localStore.DeleteObjectAtomic(e); err != nil {
148		return err
149	}
150
151	return nil
152}
153
154func (d *driver) writeEndpointToStore(e *endpoint) error {
155	if d.localStore == nil {
156		return fmt.Errorf("overlay local store not initialized, ep not added")
157	}
158
159	if err := d.localStore.PutObjectAtomic(e); err != nil {
160		return err
161	}
162	return nil
163}
164
165func (ep *endpoint) DataScope() string {
166	return datastore.LocalScope
167}
168
169func (ep *endpoint) New() datastore.KVObject {
170	return &endpoint{}
171}
172
173func (ep *endpoint) CopyTo(o datastore.KVObject) error {
174	dstep := o.(*endpoint)
175	*dstep = *ep
176	return nil
177}
178
179func (ep *endpoint) Key() []string {
180	return []string{overlayEndpointPrefix, ep.id}
181}
182
183func (ep *endpoint) KeyPrefix() []string {
184	return []string{overlayEndpointPrefix}
185}
186
187func (ep *endpoint) Index() uint64 {
188	return ep.dbIndex
189}
190
191func (ep *endpoint) SetIndex(index uint64) {
192	ep.dbIndex = index
193	ep.dbExists = true
194}
195
196func (ep *endpoint) Exists() bool {
197	return ep.dbExists
198}
199
200func (ep *endpoint) Skip() bool {
201	return false
202}
203
204func (ep *endpoint) Value() []byte {
205	b, err := json.Marshal(ep)
206	if err != nil {
207		return nil
208	}
209	return b
210}
211
212func (ep *endpoint) SetValue(value []byte) error {
213	return json.Unmarshal(value, ep)
214}
215
216func (ep *endpoint) MarshalJSON() ([]byte, error) {
217	epMap := make(map[string]interface{})
218
219	epMap["id"] = ep.id
220	epMap["nid"] = ep.nid
221	if ep.ifName != "" {
222		epMap["ifName"] = ep.ifName
223	}
224	if ep.addr != nil {
225		epMap["addr"] = ep.addr.String()
226	}
227	if len(ep.mac) != 0 {
228		epMap["mac"] = ep.mac.String()
229	}
230
231	return json.Marshal(epMap)
232}
233
234func (ep *endpoint) UnmarshalJSON(value []byte) error {
235	var (
236		err   error
237		epMap map[string]interface{}
238	)
239
240	json.Unmarshal(value, &epMap)
241
242	ep.id = epMap["id"].(string)
243	ep.nid = epMap["nid"].(string)
244	if v, ok := epMap["mac"]; ok {
245		if ep.mac, err = net.ParseMAC(v.(string)); err != nil {
246			return types.InternalErrorf("failed to decode endpoint interface mac address after json unmarshal: %s", v.(string))
247		}
248	}
249	if v, ok := epMap["addr"]; ok {
250		if ep.addr, err = types.ParseCIDR(v.(string)); err != nil {
251			return types.InternalErrorf("failed to decode endpoint interface ipv4 address after json unmarshal: %v", err)
252		}
253	}
254	if v, ok := epMap["ifName"]; ok {
255		ep.ifName = v.(string)
256	}
257
258	return nil
259}
260