cilium

1
// SPDX-License-Identifier: Apache-2.0
2
// Copyright Authors of Cilium
3

4
package driver
5

6
import (
7
	"encoding/json"
8
	"fmt"
9
	"net/http"
10

11
	"github.com/docker/libnetwork/ipams/remote/api"
12

13
	"github.com/cilium/cilium/pkg/client"
14
	"github.com/cilium/cilium/pkg/logging/logfields"
15
)
16

17
const (
18
	PoolIPv4 = "CiliumPoolv4"
19
	PoolIPv6 = "CiliumPoolv6"
20
)
21

22
func (driver *driver) ipamCapabilities(w http.ResponseWriter, r *http.Request) {
23
	err := json.NewEncoder(w).Encode(&api.GetCapabilityResponse{})
24
	if err != nil {
25
		log.WithError(err).Fatal("capabilities encode")
26
		sendError(w, "encode error", http.StatusInternalServerError)
27
		return
28
	}
29
	log.Debug("IPAM capabilities exchange complete")
30
}
31

32
func (driver *driver) getDefaultAddressSpaces(w http.ResponseWriter, r *http.Request) {
33
	log.Debug("GetDefaultAddressSpaces Called")
34

35
	resp := &api.GetAddressSpacesResponse{
36
		LocalDefaultAddressSpace:  "CiliumLocal",
37
		GlobalDefaultAddressSpace: "CiliumGlobal",
38
	}
39

40
	log.WithField(logfields.Response, logfields.Repr(resp)).Debug("Get Default Address Spaces response")
41
	objectResponse(w, resp)
42
}
43

44
func (driver *driver) getPoolResponse(req *api.RequestPoolRequest) *api.RequestPoolResponse {
45
	addr := driver.conf.Addressing
46
	if !req.V6 {
47
		return &api.RequestPoolResponse{
48
			PoolID: PoolIPv4,
49
			Pool:   "0.0.0.0/0",
50
			Data: map[string]string{
51
				"com.docker.network.gateway": addr.IPV4.IP + "/32",
52
			},
53
		}
54
	}
55

56
	return &api.RequestPoolResponse{
57
		PoolID: PoolIPv6,
58
		Pool:   addr.IPV6.AllocRange,
59
		Data: map[string]string{
60
			"com.docker.network.gateway": addr.IPV6.IP + "/128",
61
		},
62
	}
63
}
64

65
func (driver *driver) requestPool(w http.ResponseWriter, r *http.Request) {
66
	var req api.RequestPoolRequest
67

68
	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
69
		sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
70
		return
71
	}
72

73
	log.WithField(logfields.Request, logfields.Repr(&req)).Debug("Request Pool request")
74
	resp := driver.getPoolResponse(&req)
75
	log.WithField(logfields.Response, logfields.Repr(resp)).Debug("Request Pool response")
76
	objectResponse(w, resp)
77
}
78

79
func (driver *driver) releasePool(w http.ResponseWriter, r *http.Request) {
80
	var release api.ReleasePoolRequest
81
	if err := json.NewDecoder(r.Body).Decode(&release); err != nil {
82
		sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
83
		return
84
	}
85

86
	log.WithField(logfields.Request, logfields.Repr(&release)).Debug("Release Pool request")
87

88
	emptyResponse(w)
89
}
90

91
func (driver *driver) requestAddress(w http.ResponseWriter, r *http.Request) {
92
	var request api.RequestAddressRequest
93
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
94
		sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
95
		return
96
	}
97

98
	log.WithField(logfields.Request, logfields.Repr(&request)).Debug("Request Address request")
99

100
	family := client.AddressFamilyIPv6 // Default
101
	switch request.PoolID {
102
	case PoolIPv4:
103
		family = client.AddressFamilyIPv4
104
	case PoolIPv6:
105
		family = client.AddressFamilyIPv6
106
	}
107

108
	ipam, err := driver.client.IPAMAllocate(family, "docker-ipam", "", false)
109
	if err != nil {
110
		sendError(w, fmt.Sprintf("Could not allocate IP address: %s", err), http.StatusBadRequest)
111
		return
112
	}
113

114
	// The host addressing may have changed due to a daemon restart, update it
115
	driver.updateRoutes(ipam.HostAddressing)
116

117
	addr := ipam.Address
118
	if addr == nil {
119
		sendError(w, "No IP addressing provided", http.StatusBadRequest)
120
		return
121
	}
122

123
	resp := &api.RequestAddressResponse{}
124
	if addr.IPV6 != "" {
125
		if family != client.AddressFamilyIPv6 {
126
			sendError(w, "Requested IPv4, received IPv6 address", http.StatusInternalServerError)
127
		}
128
		resp.Address = addr.IPV6 + "/128"
129
	} else if addr.IPV4 != "" {
130
		if family != client.AddressFamilyIPv4 {
131
			sendError(w, "Requested IPv6, received IPv4 address", http.StatusInternalServerError)
132
		}
133
		resp.Address = addr.IPV4 + "/32"
134
	}
135

136
	log.WithField(logfields.Response, logfields.Repr(resp)).Debug("Request Address response")
137
	objectResponse(w, resp)
138
}
139

140
func (driver *driver) releaseAddress(w http.ResponseWriter, r *http.Request) {
141
	var release api.ReleaseAddressRequest
142
	if err := json.NewDecoder(r.Body).Decode(&release); err != nil {
143
		sendError(w, "Could not decode JSON encode payload", http.StatusBadRequest)
144
		return
145
	}
146

147
	log.WithField(logfields.Request, logfields.Repr(&release)).Debug("Release Address request")
148
	if err := driver.client.IPAMReleaseIP(release.Address, ""); err != nil {
149
		sendError(w, fmt.Sprintf("Could not release IP address: %s", err), http.StatusBadRequest)
150
		return
151
	}
152

153
	emptyResponse(w)
154
}
155