kerberos-io/onvif
1
0
Fork 0
mirror of https://github.com/kerberos-io/onvif.git synced 2026-08-23 15:08:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Confilcts merged

Browse Source
This commit is contained in:
yakovlevdmv
2018-04-04 23:01:53 +03:00
parent 3d9807c0eb 68f24e5a17
commit 632ff7fc30
10 changed files with 28 additions and 291 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
Device.go
View File

@@ -6,18 +6,28 @@ import (
"log"
"fmt"
"github.com/beevik/etree"
"github.com/yakovlevdmv/goonvif/Networking"
"github.com/yakovlevdmv/goonvif/networking"
"github.com/yakovlevdmv/gosoap"
"reflect"
"strings"
"github.com/yakovlevdmv/goonvif/Device"
"github.com/yakovlevdmv/goonvif/Imaging"
"github.com/yakovlevdmv/goonvif/Media"
"github.com/yakovlevdmv/goonvif/PTZ"
"errors"
"strconv"
)
var xlmns = map[string]string {
"onvif":"http://www.onvif.org/ver10/schema",
"tds":"http://www.onvif.org/ver10/device/wsdl",
"trt":"http://www.onvif.org/ver10/media/wsdl",
"tev":"http://www.onvif.org/ver10/events/wsdl",
"tpz":"http://www.onvif.org/ver20/ptz/wsdl",
"timg":"http://www.onvif.org/ver20/imaging/wsdl",
"xmime":"http://www.w3.org/2005/05/xmlmime",
"wsnt":"http://docs.oasis-open.org/wsn/b-2",
"xop":"http://www.w3.org/2004/08/xop/include",
"wsa":"http://www.w3.org/2005/08/addressing",
"wstop":"http://docs.oasis-open.org/wsn/t-1",
"wsntw":"http://docs.oasis-open.org/wsn/bw-2",
"wsrf-rw":"http://docs.oasis-open.org/wsrf/rw-2",
"wsaw":"http://www.w3.org/2006/05/addressing/wsdl",
}
type DeviceType int
const (
@@ -86,7 +96,7 @@ func (dev *device) Authenticate(username, password string) {
dev.password = password
}
func buildMethodSOAP(msg, space string) (gosoap.SoapMessage, error) {
func buildMethodSOAP(msg string) (gosoap.SoapMessage, error) {
doc := etree.NewDocument()
if err := doc.ReadFromString(msg); err != nil {
log.Println("Got error")
@@ -98,28 +108,11 @@ func buildMethodSOAP(msg, space string) (gosoap.SoapMessage, error) {
soap := gosoap.NewEmptySOAP()
soap.AddBodyContent(element)
soap.AddRootNamespace("onvif", "http://www.onvif.org/ver10/device/wsdl")
soap.AddRootNamespace("wsdl", space)
return soap, nil
}
func setXMLNamespaces(strct interface{}) (string, error) {
pkgName := reflect.TypeOf( strct ).PkgPath()
pkgSplit := strings.Split(pkgName, "/")
pkgName = pkgSplit[len(pkgSplit)-1]
switch pkgName {
case "Device":
return Device.WSDL, nil
case "Imaging":
return Imaging.WSDL, nil
case "Media":
return Media.WSDL, nil
case "PTZ":
return PTZ.WSDL, nil
default:
return "", errors.New("Can't find Service")
}
}
//CallMethod functions call an method, defined <method> struct.
//You should use Authenticate method to call authorized requests.
@@ -144,7 +137,6 @@ func (dev device) CallNonAuthorizedMethod(endpoint string, method interface{}) (
return "", err
}
wsdlSpaces, err := setXMLNamespaces(method)
if err != nil {
fmt.Println(err)
}
@@ -152,7 +144,7 @@ func (dev device) CallNonAuthorizedMethod(endpoint string, method interface{}) (
/*
Build an SOAP request with <method>
*/
soap, err := buildMethodSOAP(string(output), wsdlSpaces)
soap, err := buildMethodSOAP(string(output))
if err != nil {
log.Printf("error: %v\n", err)
return "", err
@@ -161,7 +153,7 @@ func (dev device) CallNonAuthorizedMethod(endpoint string, method interface{}) (
/*
Sending request and returns the response
*/
return Networking.SendSoap(endpoint, soap.String()), nil
return networking.SendSoap(endpoint, soap.String()), nil
}
//CallMethod functions call an method, defined <method> struct with authentication data
@@ -175,15 +167,15 @@ func (dev device) CallAuthorizedMethod(endpoint string, method interface{}) (str
return "", err
}
wsdlSpaces, err := setXMLNamespaces(method)
if err != nil {
fmt.Println(err)
}
/*
Build an SOAP request with <method>
*/
soap, err := buildMethodSOAP(string(output), wsdlSpaces)
soap, err := buildMethodSOAP(string(output))
if err != nil {
log.Fatal(err)
}
@@ -204,6 +196,7 @@ func (dev device) CallAuthorizedMethod(endpoint string, method interface{}) (str
log.Printf("error: %v\n", err.Error())
return "", err
}
/*
Adding WS-Security struct to SOAP header
*/
@@ -212,5 +205,5 @@ func (dev device) CallAuthorizedMethod(endpoint string, method interface{}) (str
/*
Sending request and returns the response
*/
return Networking.SendSoap(endpoint, soap.String()), nil
return networking.SendSoap(endpoint, soap.String()), nil
}

2
Device/types.go
View File

@@ -5,8 +5,6 @@ import (
"github.com/yakovlevdmv/goonvif/xsd/onvif"
)
const WSDL = "http://www.onvif.org/ver10/device/wsdl"
type Service struct {
Namespace xsd.AnyURI
XAddr xsd.AnyURI

2
Event/types.go
View File

@@ -4,8 +4,6 @@ import (
"github.com/yakovlevdmv/goonvif/xsd"
)
//const WSDL = "http://www.onvif.org/ver10/events/wsdl"
type FilterType struct { //wsnt http://docs.oasis-open.org/wsn/b-2.xsd
Any string
}

2
Imaging/types.go
View File

@@ -5,8 +5,6 @@ import (
"github.com/yakovlevdmv/goonvif/xsd"
)
const WSDL = "http://www.onvif.org/ver20/imaging/wsdl"
type GetServiceCapabilities struct {
XMLName string `xml:"wsdl:GetServiceCapabilities"`
}

2
Media/types.go
View File

@@ -5,8 +5,6 @@ import (
"github.com/yakovlevdmv/goonvif/xsd"
)
const WSDL = "http://www.onvif.org/ver10/media/wsdl"
type Capabilities struct {
SnapshotUri bool `xml:"SnapshotUri,attr"`
Rotation bool `xml:"Rotation,attr"`

3
PTZ/types.go
View File

@@ -11,9 +11,6 @@ type Capabilities struct {
StatusPosition xsd.Boolean `xml:"StatusPosition,attr"`
}
const WSDL = "http://www.onvif.org/ver20/ptz/wsdl"
//PTZ main types
type GetServiceCapabilities struct {

58
WS-Discovery.go
View File

@@ -1,58 +0,0 @@
package goonvif
import (
"fmt"
"net"
"golang.org/x/net/ipv4"
"time"
"log"
)
const bufSize = 5000
func SendUDPMulticast (msg* string, interfaceName string) []string {
var result []string
data := []byte(*msg)
iface, err := net.InterfaceByName(interfaceName)
if err != nil {
fmt.Println(err)
}
group := net.IPv4(239, 255, 255, 250)
c, err := net.ListenPacket("udp4", "0.0.0.0:1024")
if err != nil {
fmt.Println(err)
}
defer c.Close()
p := ipv4.NewPacketConn(c)
if err := p.JoinGroup(iface, &net.UDPAddr{IP: group}); err != nil {
fmt.Println(err)
}
dst := &net.UDPAddr{IP: group, Port: 3702}
for _, ifi := range []*net.Interface{iface} {
if err := p.SetMulticastInterface(ifi); err != nil {
fmt.Println(err)
}
p.SetMulticastTTL(2)
if _, err := p.WriteTo(data, nil, dst); err != nil {
fmt.Println(err)
}
}
if err := p.SetReadDeadline(time.Now().Add(time.Second * 1)); err != nil {
log.Fatal(err)
}
for {
b := make([]byte, bufSize)
n, _, _, err := p.ReadFrom(b)
if err != nil {
fmt.Println(err)
break
}
result = append(result, string(b[0:n]))
}
return result
}

2
Networking/networking.go → networking/networking.go
View File

@@ -1,4 +1,4 @@
package Networking
package networking
import (
"net/http"

161
soap/soap.go
View File

@@ -1,161 +0,0 @@
package goonvif
import (
"encoding/xml"
"time"
"github.com/elgs/gostrgen"
"github.com/yakovlevdmv/goonvif/scheme"
"encoding/base64"
"crypto/sha1"
"fmt"
"log"
"net/http"
"bytes"
"io/ioutil"
)
var xlmns = map[string]string {
// SOAP namespase
"soap":"http://www.w3.org/2003/05/soap-envelope",
"xs":"http://www.w3.org/2001/XMLSchema",
// ONVIF namespace
"tt":"http://www.onvif.org/ver10/schema",
"tds":"http://www.onvif.org/ver10/device/wsdl",
"trt":"http://www.onvif.org/ver10/media/wsdl",
"tev":"http://www.onvif.org/ver10/events/wsdl",
"ter":"http://www.onvif.org/ver10/error",
"dn":"http://www.onvif.org/ver10/network/wsdl",
"tns1":"http://www.onvif.org/ver10/topics",
"tpz":"http://www.onvif.org/ver20/ptz/wsdl",
"dev":"https://www.onvif.org/ver10/device/wsdl/devicemgmt.wsdl",
"xsi":"http://www.w3.org/2001/XMLSchema-instance",
"xsd":"http://www.w3.org/2001/XMLSchema",
"wsse":"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd",
"wsu":"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd",
}
var passwordType = "https://www.oasis-open.org/committees/download.php/13392/wss-v1.1-spec-pr-UsernameTokenProfile-01.htm#PasswordDigest"
type Envelope struct {
XMLName xml.Name `xml:"soap:Envelope"`
XmlnsSoap string `xml:"xmlns:soap,attr,omitempty"`
XmlnsXsi string `xml:"xmlns:xsi,attr,omitempty"`
XmlnsXsd string `xml:"xmlns:xsd,attr,omitempty"`
XmlnsTt string `xml:"xmlns:tt,attr,omitempty"`
XmlnsWsse string `xml:"xmlns:wsse,attr,omitempty"`
XmlnsWsu string `xml:"xmlns:wsu,attr,omitempty"`
XmlnsWsdl string `xml:"xmlns:wsdl,attr,omitempty"`
Header Header
Body Body
}
type Header struct {
XMLName xml.Name `xml:"soap:Header"`
WSAuth Security
}
type BodyContent struct {
XMLName xml.Name
Content string `xml:",innerxml"`
}
type Body struct {
XMLName xml.Name `xml:"soap:Body"`
Content BodyContent
}
type Security struct {
XMLName xml.Name `xml:"wsse:Security"`
Auth WSAuth
}
type Password struct {
XMLName xml.Name `xml:"wsse:Password"`
Type string `xml:"Type,attr"`
Password string `xml:",chardata"`
}
type WSAuth struct {
XMLName xml.Name `xml:"wsse:UsernameToken"`
Username string `xml:"wsse:Username"`
Password Password `xml:"wsse:Password"`
Nonce string `xml:"wsse:Nonce"`
Created string `xml:"wsse:Created"`
}
//Digest = B64ENCODE( SHA1( B64DECODE( Nonce ) + Date + Password ) )
func generateToken(Username string, Nonce string, Created time.Time, Password string) string {
sDec, _ := base64.StdEncoding.DecodeString(Nonce)
hasher := sha1.New()
//hasher.Write([]byte((base64.StdEncoding.EncodeToString([]byte(Nonce)) + Created.Format(time.RFC3339) + Password)))
hasher.Write([]byte(string(sDec) + Created.Format(time.RFC3339) + Password))
return base64.StdEncoding.EncodeToString(hasher.Sum(nil))
}
//func (t *emptyInput)createSelfCloseTag() string {
// t.EmptyInput
//}
func NewEnvelope( funcName string, data scheme.TypeWorker ) Envelope {
/** Generating Nonce sequence **/
charsToGenerate := 16
charSet := gostrgen.Lower | gostrgen.Digit
nonce, _ := gostrgen.RandGen(charsToGenerate, charSet, "", "")
output, err := xml.MarshalIndent(data, "", " ")
if err != nil {
log.Fatal(err)
}
var soapData = Envelope{
XmlnsSoap:xlmns["soap"],
XmlnsXsd:xlmns["xsd"],
XmlnsXsi:xlmns["xsi"],
XmlnsWsdl:xlmns["dev"],
XmlnsTt:xlmns["tt"],
XmlnsWsse:xlmns["wsse"],
XmlnsWsu:xlmns["wsu"],
Header:Header {
WSAuth:Security {
Auth:WSAuth {
Username:"admin",
Password:Password {
Type:passwordType,
Password:generateToken("admin", nonce, time.Now(), "Supervisor"),
},
Nonce: nonce,
Created: time.Now().Format(time.RFC3339),
},
},
},
Body:Body{
Content:BodyContent{
XMLName:xml.Name{Local:"wsdl:" + funcName},
Content:"\n\t"+string(output)+"\n",},
},
}
return soapData
}
func SendSoap() {
env := NewEnvelope("GetDNS", nil)
soapReq, _ := xml.MarshalIndent(env, "", " ")
httpClient := new(http.Client)
resp, _ := httpClient.Post("http://192.168.13.53", "application/soap+xml; charset=utf-8", bytes.NewBufferString(string(soapReq)))
b, _ := ioutil.ReadAll(resp.Body)
fmt.Println(string(b))
}

28
xsd/onvif/onvif.go
View File

@@ -6,8 +6,6 @@ import (
// BUG(r): Enum types implemented as simple string
const ONVIF = "http://www.onvif.org/ver10/schema"
//TODO: enumerations
//TODO: type <typeName> struct {Any string} convert to type <typeName> AnyType
//TODO: process restrictions
@@ -1873,28 +1871,4 @@ type Date struct {
Year xsd.Int `xml:"onvif:Year"`
Month xsd.Int `xml:"onvif:Month"`
Day xsd.Int `xml:"onvif:Day"`
}
}