func Factomd() {
log.Print("//////////////////////// Copyright 2015 Factom Foundation")
log.Print("//////////////////////// Use of this source code is governed by the MIT")
log.Print("//////////////////////// license that can be found in the LICENSE file.")
log.Printf("Go compiler version: %s\n", runtime.Version())
log.Printf("Using build: %s\n", Build)
if !isCompilerVersionOK() {
for i := 0; i < 30; i++ {
log.Println("!!! !!! !!! ERROR: unsupported compiler version !!! !!! !!!")
}
time.Sleep(3 * time.Second)
os.Exit(1)
}
// Go Optimizations...
runtime.GOMAXPROCS(runtime.NumCPU())
state0 := new(state.State)
state0.SetLeaderTimestamp(primitives.NewTimestampFromMilliseconds(0))
fmt.Println("len(Args)", len(os.Args))
NetStart(state0)
}
// This routine is called once we have everything to create a Directory Block.
// It is called by the follower code. It is requried to build the Directory Block
// to validate the signatures we will get with the DirectoryBlockSignature messages.
func (s *State) ProcessEndOfBlock() {
s.PreviousDirectoryBlock = s.CurrentDirectoryBlock
previousECBlock := s.GetCurrentEntryCreditBlock()
s.FactoidState.ProcessEndOfBlock(s) // Clean up Factoids
db, err := s.CreateDBlock()
if err != nil {
panic("Failed to create a Directory Block")
}
if previousECBlock != nil {
s.DB.ProcessECBlockBatch(previousECBlock)
}
s.SetCurrentDirectoryBlock(db)
if s.PreviousDirectoryBlock != nil {
if err = s.DB.SaveDirectoryBlockHead(s.PreviousDirectoryBlock); err != nil {
panic(err.Error())
}
s.Anchor.UpdateDirBlockInfoMap(dbInfo.NewDirBlockInfoFromDirBlock(s.PreviousDirectoryBlock))
} else {
log.Println("No old db")
}
s.ProcessList = make([][]interfaces.IMsg, 1)
}
// Should only be called if the Identity is being initialized.
// Using this will not send any message out if a key is changed.
// Eg. Only call from addserver or you don't want any messages being sent.
func LoadIdentityByEntryBlock(eblk interfaces.IEntryBlock, st *State) {
if eblk == nil {
log.Println("DEBUG: Identity Error, EBlock nil, disregard")
return
}
cid := eblk.GetChainID()
if cid == nil {
return
}
if index := st.isIdentityChain(cid); index != -1 {
entryHashes := eblk.GetEntryHashes()
for _, eHash := range entryHashes {
entry, err := st.DB.FetchEntry(eHash)
if err != nil {
continue
}
LoadIdentityByEntry(entry, st, eblk.GetDatabaseHeight(), true)
}
}
}
func (st *State) UpdateAuthorityFromABEntry(entry interfaces.IABEntry) error {
var AuthorityIndex int
data, err := entry.MarshalBinary()
if err != nil {
return err
}
switch entry.Type() {
case constants.TYPE_REVEAL_MATRYOSHKA:
r := new(adminBlock.RevealMatryoshkaHash)
err := r.UnmarshalBinary(data)
if err != nil {
return err
}
// Does nothing for authority right now
case constants.TYPE_ADD_MATRYOSHKA:
m := new(adminBlock.AddReplaceMatryoshkaHash)
err := m.UnmarshalBinary(data)
if err != nil {
return err
}
AuthorityIndex = st.AddAuthorityFromChainID(m.IdentityChainID)
st.Authorities[AuthorityIndex].MatryoshkaHash = m.MHash
case constants.TYPE_ADD_SERVER_COUNT:
s := new(adminBlock.IncreaseServerCount)
err := s.UnmarshalBinary(data)
if err != nil {
return err
}
st.AuthorityServerCount = st.AuthorityServerCount + int(s.Amount)
case constants.TYPE_ADD_FED_SERVER:
f := new(adminBlock.AddFederatedServer)
err := f.UnmarshalBinary(data)
if err != nil {
return err
}
err = st.AddIdentityFromChainID(f.IdentityChainID)
if err != nil {
//fmt.Println("Error when Making Identity,", err)
}
AuthorityIndex = st.AddAuthorityFromChainID(f.IdentityChainID)
st.Authorities[AuthorityIndex].Status = constants.IDENTITY_FEDERATED_SERVER
// check Identity status
UpdateIdentityStatus(f.IdentityChainID, constants.IDENTITY_FEDERATED_SERVER, st)
case constants.TYPE_ADD_AUDIT_SERVER:
a := new(adminBlock.AddAuditServer)
err := a.UnmarshalBinary(data)
if err != nil {
return err
}
err = st.AddIdentityFromChainID(a.IdentityChainID)
if err != nil {
//fmt.Println("Error when Making Identity,", err)
}
AuthorityIndex = st.AddAuthorityFromChainID(a.IdentityChainID)
st.Authorities[AuthorityIndex].Status = constants.IDENTITY_AUDIT_SERVER
// check Identity status
UpdateIdentityStatus(a.IdentityChainID, constants.IDENTITY_AUDIT_SERVER, st)
case constants.TYPE_REMOVE_FED_SERVER:
f := new(adminBlock.RemoveFederatedServer)
err := f.UnmarshalBinary(data)
if err != nil {
return err
}
AuthorityIndex = st.isAuthorityChain(f.IdentityChainID)
if AuthorityIndex == -1 {
log.Println(f.IdentityChainID.String() + " Cannot be removed. Not in Authorities List.")
} else {
st.RemoveAuthority(f.IdentityChainID)
IdentityIndex := st.isIdentityChain(f.IdentityChainID)
if IdentityIndex != -1 && IdentityIndex < len(st.Identities) {
if st.Identities[IdentityIndex].IdentityChainID.IsSameAs(st.IdentityChainID) {
st.Identities[IdentityIndex].Status = constants.IDENTITY_SELF
} else {
st.removeIdentity(IdentityIndex)
}
}
}
case constants.TYPE_ADD_FED_SERVER_KEY:
f := new(adminBlock.AddFederatedServerSigningKey)
err := f.UnmarshalBinary(data)
if err != nil {
return err
}
keyBytes, err := f.PublicKey.MarshalBinary()
if err != nil {
return err
}
key := new(primitives.Hash)
err = key.SetBytes(keyBytes)
if err != nil {
return err
}
addServerSigningKey(f.IdentityChainID, key, f.DBHeight, st)
case constants.TYPE_ADD_BTC_ANCHOR_KEY:
b := new(adminBlock.AddFederatedServerBitcoinAnchorKey)
err := b.UnmarshalBinary(data)
if err != nil {
return err
}
pubKey, err := b.ECDSAPublicKey.MarshalBinary()
if err != nil {
return err
}
registerAuthAnchor(b.IdentityChainID, pubKey, b.KeyType, b.KeyPriority, st, "BTC")
}
return nil
}
// Called by AddServer Message
func ProcessIdentityToAdminBlock(st *State, chainID interfaces.IHash, servertype int) bool {
var matryoshkaHash interfaces.IHash
var blockSigningKey [32]byte
var btcKey [20]byte
var btcKeyLevel byte
var btcKeyType byte
err := st.AddIdentityFromChainID(chainID)
if err != nil {
log.Println(err.Error())
return true
}
index := st.isIdentityChain(chainID)
if index != -1 {
id := st.Identities[index]
zero := primitives.NewZeroHash()
if id.SigningKey == nil || id.SigningKey.IsSameAs(zero) {
log.Println("New Fed/Audit server [" + chainID.String()[:10] + "] does not have an Block Signing Key associated to it")
if !statusIsFedOrAudit(id.Status) {
st.removeIdentity(index)
}
return true
} else {
copy(blockSigningKey[:32], id.SigningKey.Bytes()[:32])
}
if id.AnchorKeys == nil {
log.Println("New Fed/Audit server [" + chainID.String()[:10] + "] does not have an BTC Anchor Key associated to it")
if !statusIsFedOrAudit(id.Status) {
st.removeIdentity(index)
}
return true
} else {
for _, aKey := range id.AnchorKeys {
if strings.Compare(aKey.BlockChain, "BTC") == 0 {
copy(btcKey[:20], aKey.SigningKey[:20])
}
}
}
if id.MatryoshkaHash == nil || id.MatryoshkaHash.IsSameAs(zero) {
log.Println("New Fed/Audit server [" + chainID.String()[:10] + "] does not have an Matryoshka Hash associated to it")
if !statusIsFedOrAudit(id.Status) {
st.removeIdentity(index)
}
return true
}
matryoshkaHash = id.MatryoshkaHash
if servertype == 0 {
id.Status = constants.IDENTITY_PENDING_FEDERATED_SERVER
} else if servertype == 1 {
id.Status = constants.IDENTITY_PENDING_AUDIT_SERVER
}
st.Identities[index] = id
} else {
log.Println("New Fed/Audit server [" + chainID.String()[:10] + "] does not have an identity associated to it")
return true
}
// Add to admin block
if servertype == 0 {
st.LeaderPL.AdminBlock.AddFedServer(chainID)
st.Identities[index].Status = constants.IDENTITY_PENDING_FEDERATED_SERVER
} else if servertype == 1 {
st.LeaderPL.AdminBlock.AddAuditServer(chainID)
st.Identities[index].Status = constants.IDENTITY_PENDING_AUDIT_SERVER
}
st.LeaderPL.AdminBlock.AddFederatedServerSigningKey(chainID, &blockSigningKey)
st.LeaderPL.AdminBlock.AddMatryoshkaHash(chainID, matryoshkaHash)
st.LeaderPL.AdminBlock.AddFederatedServerBitcoinAnchorKey(chainID, btcKeyLevel, btcKeyType, &btcKey)
return true
}