github.com/keltia/go-ipfs@v0.3.8-0.20150909044612-210793031c63/repo/config/init.go (about)

     1  package config
     2  
     3  import (
     4  	"encoding/base64"
     5  	"errors"
     6  	"fmt"
     7  	"io"
     8  
     9  	ci "github.com/ipfs/go-ipfs/p2p/crypto"
    10  	peer "github.com/ipfs/go-ipfs/p2p/peer"
    11  )
    12  
    13  func Init(out io.Writer, nBitsForKeypair int) (*Config, error) {
    14  	ds, err := datastoreConfig()
    15  	if err != nil {
    16  		return nil, err
    17  	}
    18  
    19  	identity, err := identityConfig(out, nBitsForKeypair)
    20  	if err != nil {
    21  		return nil, err
    22  	}
    23  
    24  	bootstrapPeers, err := DefaultBootstrapPeers()
    25  	if err != nil {
    26  		return nil, err
    27  	}
    28  
    29  	snr, err := initSNRConfig()
    30  	if err != nil {
    31  		return nil, err
    32  	}
    33  
    34  	conf := &Config{
    35  
    36  		// setup the node's default addresses.
    37  		// Note: two swarm listen addrs, one tcp, one utp.
    38  		Addresses: Addresses{
    39  			Swarm: []string{
    40  				"/ip4/0.0.0.0/tcp/4001",
    41  				// "/ip4/0.0.0.0/udp/4002/utp", // disabled for now.
    42  				"/ip6/::/tcp/4001",
    43  			},
    44  			API:     "/ip4/127.0.0.1/tcp/5001",
    45  			Gateway: "/ip4/127.0.0.1/tcp/8080",
    46  		},
    47  
    48  		Bootstrap:        BootstrapPeerStrings(bootstrapPeers),
    49  		SupernodeRouting: *snr,
    50  		Datastore:        *ds,
    51  		Identity:         identity,
    52  		Discovery: Discovery{MDNS{
    53  			Enabled:  true,
    54  			Interval: 10,
    55  		}},
    56  		Log: Log{
    57  			MaxSizeMB:  250,
    58  			MaxBackups: 1,
    59  		},
    60  
    61  		// setup the node mount points.
    62  		Mounts: Mounts{
    63  			IPFS: "/ipfs",
    64  			IPNS: "/ipns",
    65  		},
    66  
    67  		// tracking ipfs version used to generate the init folder and adding
    68  		// update checker default setting.
    69  		Version: VersionDefaultValue(),
    70  
    71  		Gateway: Gateway{
    72  			RootRedirect: "",
    73  			Writable:     false,
    74  		},
    75  	}
    76  
    77  	return conf, nil
    78  }
    79  
    80  func datastoreConfig() (*Datastore, error) {
    81  	dspath, err := DataStorePath("")
    82  	if err != nil {
    83  		return nil, err
    84  	}
    85  	return &Datastore{
    86  		Path: dspath,
    87  		Type: "leveldb",
    88  	}, nil
    89  }
    90  
    91  // identityConfig initializes a new identity.
    92  func identityConfig(out io.Writer, nbits int) (Identity, error) {
    93  	// TODO guard higher up
    94  	ident := Identity{}
    95  	if nbits < 1024 {
    96  		return ident, errors.New("Bitsize less than 1024 is considered unsafe.")
    97  	}
    98  
    99  	fmt.Fprintf(out, "generating %v-bit RSA keypair...", nbits)
   100  	sk, pk, err := ci.GenerateKeyPair(ci.RSA, nbits)
   101  	if err != nil {
   102  		return ident, err
   103  	}
   104  	fmt.Fprintf(out, "done\n")
   105  
   106  	// currently storing key unencrypted. in the future we need to encrypt it.
   107  	// TODO(security)
   108  	skbytes, err := sk.Bytes()
   109  	if err != nil {
   110  		return ident, err
   111  	}
   112  	ident.PrivKey = base64.StdEncoding.EncodeToString(skbytes)
   113  
   114  	id, err := peer.IDFromPublicKey(pk)
   115  	if err != nil {
   116  		return ident, err
   117  	}
   118  	ident.PeerID = id.Pretty()
   119  	fmt.Fprintf(out, "peer identity: %s\n", ident.PeerID)
   120  	return ident, nil
   121  }