mirror of
https://github.com/octoleo/syncthing.git
synced 2024-11-10 15:20:56 +00:00
8f3effed32
New node ID:s contain four Luhn check digits and are grouped differently. Code uses NodeID type instead of string, so it's formatted homogenously everywhere.
147 lines
3.2 KiB
Go
147 lines
3.2 KiB
Go
// Copyright (C) 2014 Jakob Borg and other contributors. All rights reserved.
|
|
// Use of this source code is governed by an MIT-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
package main
|
|
|
|
import (
|
|
"crypto/tls"
|
|
"flag"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
"path/filepath"
|
|
|
|
"github.com/calmh/syncthing/protocol"
|
|
)
|
|
|
|
var (
|
|
exit bool
|
|
cmd string
|
|
confDir string
|
|
target string
|
|
get string
|
|
pc protocol.Connection
|
|
)
|
|
|
|
func main() {
|
|
log.SetFlags(0)
|
|
log.SetOutput(os.Stdout)
|
|
|
|
flag.StringVar(&cmd, "cmd", "idx", "Command")
|
|
flag.StringVar(&confDir, "home", ".", "Certificates directory")
|
|
flag.StringVar(&target, "target", "127.0.0.1:22000", "Target node")
|
|
flag.StringVar(&get, "get", "", "Get file")
|
|
flag.BoolVar(&exit, "exit", false, "Exit after command")
|
|
flag.Parse()
|
|
|
|
connect(target)
|
|
|
|
select {}
|
|
}
|
|
|
|
func connect(target string) {
|
|
cert, err := loadCert(confDir)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
myID := protocol.NewNodeID(cert.Certificate[0])
|
|
|
|
tlsCfg := &tls.Config{
|
|
Certificates: []tls.Certificate{cert},
|
|
NextProtos: []string{"bep/1.0"},
|
|
ServerName: myID.String(),
|
|
ClientAuth: tls.RequestClientCert,
|
|
SessionTicketsDisabled: true,
|
|
InsecureSkipVerify: true,
|
|
MinVersion: tls.VersionTLS12,
|
|
}
|
|
|
|
conn, err := tls.Dial("tcp", target, tlsCfg)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
remoteID := protocol.NewNodeID(conn.ConnectionState().PeerCertificates[0].Raw)
|
|
|
|
pc = protocol.NewConnection(remoteID, conn, conn, Model{})
|
|
|
|
select {}
|
|
}
|
|
|
|
type Model struct {
|
|
}
|
|
|
|
func prtIndex(files []protocol.FileInfo) {
|
|
for _, f := range files {
|
|
log.Printf("%q (v:%d mod:%d flags:0%o nblocks:%d)", f.Name, f.Version, f.Modified, f.Flags, len(f.Blocks))
|
|
for _, b := range f.Blocks {
|
|
log.Printf(" %6d %x", b.Size, b.Hash)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m Model) Index(nodeID protocol.NodeID, repo string, files []protocol.FileInfo) {
|
|
log.Printf("Received index for repo %q", repo)
|
|
if cmd == "idx" {
|
|
prtIndex(files)
|
|
if get != "" {
|
|
for _, f := range files {
|
|
if f.Name == get {
|
|
go getFile(f)
|
|
break
|
|
}
|
|
}
|
|
} else if exit {
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
func getFile(f protocol.FileInfo) {
|
|
fn := filepath.Base(f.Name)
|
|
fd, err := os.Create(fn)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
var offset int64
|
|
for _, b := range f.Blocks {
|
|
log.Printf("Request %q %d - %d", f.Name, offset, offset+int64(b.Size))
|
|
bs, err := pc.Request("default", f.Name, offset, int(b.Size))
|
|
log.Printf(" - got %d bytes", len(bs))
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
offset += int64(b.Size)
|
|
fd.Write(bs)
|
|
}
|
|
|
|
fd.Close()
|
|
}
|
|
|
|
func (m Model) IndexUpdate(nodeID protocol.NodeID, repo string, files []protocol.FileInfo) {
|
|
log.Printf("Received index update for repo %q", repo)
|
|
if cmd == "idx" {
|
|
prtIndex(files)
|
|
if exit {
|
|
os.Exit(0)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (m Model) ClusterConfig(nodeID protocol.NodeID, config protocol.ClusterConfigMessage) {
|
|
log.Println("Received cluster config")
|
|
log.Printf("%#v", config)
|
|
}
|
|
|
|
func (m Model) Request(nodeID protocol.NodeID, repo string, name string, offset int64, size int) ([]byte, error) {
|
|
log.Println("Received request")
|
|
return nil, io.EOF
|
|
}
|
|
|
|
func (m Model) Close(nodeID protocol.NodeID, err error) {
|
|
log.Println("Received close")
|
|
}
|