| // Copyright 2015 CNI authors | |
| // | |
| // Licensed under the Apache License, Version 2.0 (the "License"); | |
| // you may not use this file except in compliance with the License. | |
| // You may obtain a copy of the License at | |
| // | |
| // http://www.apache.org/licenses/LICENSE-2.0 | |
| // | |
| // Unless required by applicable law or agreed to in writing, software | |
| // distributed under the License is distributed on an "AS IS" BASIS, | |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| // See the License for the specific language governing permissions and | |
| // limitations under the License. | |
| package main | |
| import ( | |
| "encoding/json" | |
| "flag" | |
| "fmt" | |
| "log" | |
| "net/rpc" | |
| "os" | |
| "path/filepath" | |
| "time" | |
| "github.com/containernetworking/cni/pkg/skel" | |
| "github.com/containernetworking/cni/pkg/types" | |
| current "github.com/containernetworking/cni/pkg/types/100" | |
| "github.com/containernetworking/cni/pkg/version" | |
| bv "github.com/containernetworking/plugins/pkg/utils/buildversion" | |
| ) | |
| const defaultSocketPath = "/run/cni/dhcp.sock" | |
| // The top-level network config - IPAM plugins are passed the full configuration | |
| // of the calling plugin, not just the IPAM section. | |
| type NetConf struct { | |
| types.NetConf | |
| IPAM *IPAMConfig `json:"ipam"` | |
| } | |
| type IPAMConfig struct { | |
| types.IPAM | |
| DaemonSocketPath string `json:"daemonSocketPath"` | |
| // When requesting IP from DHCP server, carry these options for management purpose. | |
| // Some fields have default values, and can be override by setting a new option with the same name at here. | |
| ProvideOptions []ProvideOption `json:"provide"` | |
| // When requesting IP from DHCP server, claiming these options are necessary. Options are necessary unless `optional` | |
| // is set to `false`. | |
| // To override default requesting fields, set `skipDefault` to `false`. | |
| // If an field is not optional, but the server failed to provide it, error will be raised. | |
| RequestOptions []RequestOption `json:"request"` | |
| // The metric of routes | |
| Priority int `json:"priority,omitempty"` | |
| } | |
| // DHCPOption represents a DHCP option. It can be a number, or a string defined in manual dhcp-options(5). | |
| // Note that not all DHCP options are supported at all time. Error will be raised if unsupported options are used. | |
| type DHCPOption string | |
| type ProvideOption struct { | |
| Option DHCPOption `json:"option"` | |
| Value string `json:"value"` | |
| ValueFromCNIArg string `json:"fromArg"` | |
| } | |
| type RequestOption struct { | |
| SkipDefault bool `json:"skipDefault"` | |
| Option DHCPOption `json:"option"` | |
| } | |
| func main() { | |
| if len(os.Args) > 1 && os.Args[1] == "daemon" { | |
| var pidfilePath string | |
| var hostPrefix string | |
| var socketPath string | |
| var broadcast bool | |
| var timeout time.Duration | |
| var resendMax time.Duration | |
| var resendTimeout time.Duration | |
| daemonFlags := flag.NewFlagSet("daemon", flag.ExitOnError) | |
| daemonFlags.StringVar(&pidfilePath, "pidfile", "", "optional path to write daemon PID to") | |
| daemonFlags.StringVar(&hostPrefix, "hostprefix", "", "optional prefix to host root") | |
| daemonFlags.StringVar(&socketPath, "socketpath", "", "optional dhcp server socketpath") | |
| daemonFlags.BoolVar(&broadcast, "broadcast", false, "broadcast DHCP leases") | |
| daemonFlags.DurationVar(&timeout, "timeout", 10*time.Second, "optional dhcp client timeout duration for each request") | |
| daemonFlags.DurationVar(&resendMax, "resendmax", resendDelayMax, "optional dhcp client max resend delay between requests") | |
| daemonFlags.DurationVar(&resendTimeout, "resendtimeout", defaultResendTimeout, "optional dhcp client resend timeout, no more retries after this timeout") | |
| daemonFlags.Parse(os.Args[2:]) | |
| if socketPath == "" { | |
| socketPath = defaultSocketPath | |
| } | |
| if err := runDaemon(pidfilePath, hostPrefix, socketPath, timeout, resendMax, resendTimeout, broadcast); err != nil { | |
| log.Print(err.Error()) | |
| os.Exit(1) | |
| } | |
| } else { | |
| skel.PluginMainFuncs(skel.CNIFuncs{ | |
| Add: cmdAdd, | |
| Check: cmdCheck, | |
| Del: cmdDel, | |
| /* FIXME GC */ | |
| /* FIXME Status */ | |
| }, version.All, bv.BuildString("dhcp")) | |
| } | |
| } | |
| func cmdAdd(args *skel.CmdArgs) error { | |
| // Plugin must return result in same version as specified in netconf | |
| versionDecoder := &version.ConfigDecoder{} | |
| confVersion, err := versionDecoder.Decode(args.StdinData) | |
| if err != nil { | |
| return err | |
| } | |
| result := ¤t.Result{CNIVersion: current.ImplementedSpecVersion} | |
| if err := rpcCall("DHCP.Allocate", args, result); err != nil { | |
| return err | |
| } | |
| return types.PrintResult(result, confVersion) | |
| } | |
| func cmdDel(args *skel.CmdArgs) error { | |
| result := struct{}{} | |
| return rpcCall("DHCP.Release", args, &result) | |
| } | |
| func cmdCheck(args *skel.CmdArgs) error { | |
| // Plugin must return result in same version as specified in netconf | |
| versionDecoder := &version.ConfigDecoder{} | |
| // confVersion, err := versionDecoder.Decode(args.StdinData) | |
| _, err := versionDecoder.Decode(args.StdinData) | |
| if err != nil { | |
| return err | |
| } | |
| result := ¤t.Result{CNIVersion: current.ImplementedSpecVersion} | |
| return rpcCall("DHCP.Allocate", args, result) | |
| } | |
| func getSocketPath(stdinData []byte) (string, error) { | |
| conf := NetConf{} | |
| if err := json.Unmarshal(stdinData, &conf); err != nil { | |
| return "", fmt.Errorf("error parsing socket path conf: %v", err) | |
| } | |
| if conf.IPAM.DaemonSocketPath == "" { | |
| return defaultSocketPath, nil | |
| } | |
| return conf.IPAM.DaemonSocketPath, nil | |
| } | |
| func rpcCall(method string, args *skel.CmdArgs, result interface{}) error { | |
| socketPath, err := getSocketPath(args.StdinData) | |
| if err != nil { | |
| return fmt.Errorf("error obtaining socketPath: %v", err) | |
| } | |
| client, err := rpc.DialHTTP("unix", socketPath) | |
| if err != nil { | |
| return fmt.Errorf("error dialing DHCP daemon: %v", err) | |
| } | |
| // The daemon may be running under a different working dir | |
| // so make sure the netns path is absolute. | |
| netns, err := filepath.Abs(args.Netns) | |
| if err != nil { | |
| return fmt.Errorf("failed to make %q an absolute path: %v", args.Netns, err) | |
| } | |
| args.Netns = netns | |
| err = client.Call(method, args, result) | |
| if err != nil { | |
| return fmt.Errorf("error calling %v: %v", method, err) | |
| } | |
| return nil | |
| } |