src/cypherpunks.ru/govpn/server/common.go

   1 /*
   2 GoVPN -- simple secure free software virtual private network daemon
   3 Copyright (C) 2014-2017 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 package server
  20
  21 import (
  22         "github.com/pkg/errors"
  23
  24         "cypherpunks.ru/govpn"
  25 )
  26
  27 const logFuncPrefix = "govpn/server."
  28
  29 var (
  30         errMisconfiguredTap = errors.New("No PreUp and no Iface, can't create interface")
  31         errPreUpNoTap       = errors.New("PreUp didn't returned an interface, and Iface is unset")
  32 )
  33
  34 func (s *Server) callUp(peer *govpn.Peer, proto govpn.Protocol) (*govpn.TAP, error) {
  35         var (
  36                 tap           *govpn.TAP
  37                 conf          = s.confs.Get(*peer.ID)
  38                 err           error
  39                 isConfigIface = len(conf.Iface) != 0
  40                 fields        = s.LogFields()
  41         )
  42         fields["func"] = logFuncPrefix + "Server.callUp"
  43
  44         if !isConfigIface && conf.PreUp == nil {
  45                 return nil, errors.Wrapf(errMisconfiguredTap, "interface:%q, PreUp:%q", conf.Iface, conf.PreUp)
  46         }
  47
  48         if conf.PreUp != nil {
  49                 s.logger.WithFields(fields).Debug("PreUp defined, execute it")
  50                 tap, err = conf.PreUp(govpn.PeerContext{
  51                         RemoteAddress: peer.Addr,
  52                         Protocol:      proto,
  53                         Config:        *conf,
  54                 })
  55                 if err != nil {
  56                         return nil, errors.Wrap(err, "conf.PreUp")
  57                 }
  58                 s.logger.WithFields(fields).WithField("tap", tap).Debug("PreUp finished")
  59         } else {
  60                 s.logger.WithFields(fields).Debug("No PreUp defined, skip")
  61         }
  62
  63         if tap == nil {
  64                 s.logger.WithFields(fields).Debug("PreUp didn't returned an interface, create one")
  65                 if !isConfigIface {
  66                         return nil, errors.Wrapf(errPreUpNoTap, "interface:%q tap:%q", conf.Iface, tap)
  67                 }
  68
  69                 if tap, err = govpn.TAPListen(conf.Iface, peer.MTU); err != nil {
  70                         return nil, errors.Wrap(err, "govpn.TAPListen")
  71                 }
  72         }
  73
  74         conf.Iface = tap.Name
  75
  76         if conf.Up == nil {
  77                 s.logger.WithFields(fields).Debug("Got interface, no Up")
  78                 return tap, nil
  79         }
  80         s.logger.WithFields(fields).Debug("Got interface, execute Up")
  81
  82         err = conf.Up(govpn.PeerContext{
  83                 RemoteAddress: peer.Addr,
  84                 Protocol:      proto,
  85                 Config:        *conf,
  86         })
  87         if err != nil {
  88                 return nil, errors.Wrap(err, "conf.Up")
  89         }
  90         s.logger.WithFields(fields).Debug("Got interface, Up executed")
  91         return tap, nil
  92 }
  93
  94 func (s *Server) callDown(ps *PeerState) error {
  95         fields := s.LogFields()
  96         fields["func"] = logFuncPrefix + "Server.callDown"
  97
  98         conf := s.confs.Get(*ps.peer.ID)
  99         if conf == nil {
 100                 s.logger.WithFields(fields).Error("Couldn't get configuration")
 101                 return nil
 102         }
 103         if conf.Down == nil {
 104                 s.logger.WithFields(fields).Debug("No Down, skip")
 105                 return nil
 106         }
 107         s.logger.WithFields(fields).Debug("Execute Down")
 108         err := conf.Down(govpn.PeerContext{
 109                 RemoteAddress: ps.peer.Addr,
 110                 Config:        *conf,
 111                 Protocol:      ps.peer.Protocol,
 112         })
 113         s.logger.WithFields(fields).Debug("Down executed")
 114         return errors.Wrap(err, "peer.Down")
 115 }