Line data    Source code

       1             : #include "fd_repair.h"
       2             : #include "../../ballet/sha256/fd_sha256.h"
       3             : 
       4             : void *
       5           0 : fd_repair_new( void * shmem, fd_pubkey_t * identity_key ) {
       6             : 
       7           0 :   if( FD_UNLIKELY( !shmem ) ) {
       8           0 :     FD_LOG_WARNING(( "NULL mem" ));
       9           0 :     return NULL;
      10           0 :   }
      11             : 
      12           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned( (ulong)shmem, fd_repair_align() ) ) ) {
      13           0 :     FD_LOG_WARNING(( "misaligned mem" ));
      14           0 :     return NULL;
      15           0 :   }
      16             : 
      17           0 :   ulong footprint = fd_repair_footprint();
      18           0 :   fd_memset( shmem, 0, footprint );
      19             : 
      20           0 :   fd_repair_t * repair = (fd_repair_t *)shmem;
      21           0 :   repair->identity_key = *identity_key;
      22             : 
      23           0 :   return shmem;
      24           0 : }
      25             : 
      26             : fd_repair_t *
      27           0 : fd_repair_join( void * shrepair ) {
      28           0 :   fd_repair_t * repair = (fd_repair_t *)shrepair;
      29             : 
      30           0 :   if( FD_UNLIKELY( !repair ) ) {
      31           0 :     FD_LOG_WARNING(( "NULL repair" ));
      32           0 :     return NULL;
      33           0 :   }
      34             : 
      35           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned((ulong)repair, fd_repair_align() ) ) ) {
      36           0 :     FD_LOG_WARNING(( "misaligned repair" ));
      37           0 :     return NULL;
      38           0 :   }
      39             : 
      40           0 :   fd_wksp_t * wksp = fd_wksp_containing( repair );
      41           0 :   if( FD_UNLIKELY( !wksp ) ) {
      42           0 :     FD_LOG_WARNING(( "repair must be part of a workspace" ));
      43           0 :     return NULL;
      44           0 :   }
      45             : 
      46           0 :   return repair;
      47           0 : }
      48             : 
      49             : void *
      50           0 : fd_repair_leave( fd_repair_t const * repair ) {
      51             : 
      52           0 :   if( FD_UNLIKELY( !repair ) ) {
      53           0 :     FD_LOG_WARNING(( "NULL repair" ));
      54           0 :     return NULL;
      55           0 :   }
      56             : 
      57           0 :   return (void *)repair;
      58           0 : }
      59             : 
      60             : void *
      61           0 : fd_repair_delete( void * repair ) {
      62             : 
      63           0 :   if( FD_UNLIKELY( !repair ) ) {
      64           0 :     FD_LOG_WARNING(( "NULL repair" ));
      65           0 :     return NULL;
      66           0 :   }
      67             : 
      68           0 :   if( FD_UNLIKELY( !fd_ulong_is_aligned((ulong)repair, fd_repair_align() ) ) ) {
      69           0 :     FD_LOG_WARNING(( "misaligned repair" ));
      70           0 :     return NULL;
      71           0 :   }
      72             : 
      73           0 :   return repair;
      74           0 : }
      75             : 
      76             : fd_repair_msg_t *
      77           0 : fd_repair_pong( fd_repair_t * repair, fd_hash_t * ping_token ) {
      78           0 :   uchar pre_image[FD_REPAIR_PONG_PREIMAGE_SZ];
      79           0 :   memcpy( pre_image, "SOLANA_PING_PONG", 16UL );
      80           0 :   memcpy( pre_image+16UL, ping_token->uc, 32UL);
      81             : 
      82             :   /* Generate response hash token */
      83           0 :   fd_sha256_hash( pre_image, FD_REPAIR_PONG_PREIMAGE_SZ, &repair->msg.pong.hash );
      84             : 
      85           0 :   repair->msg.kind      = FD_REPAIR_KIND_PONG;
      86           0 :   repair->msg.pong.from = repair->identity_key;
      87           0 :   return &repair->msg;
      88           0 : }
      89             : 
      90             : fd_repair_msg_t *
      91             : fd_repair_shred( fd_repair_t *     repair,
      92             :                  fd_pubkey_t const * to,
      93             :                  ulong             ts,
      94             :                  uint              nonce,
      95             :                  ulong             slot,
      96           0 :                  ulong             shred_idx ) {
      97           0 :   memset(&repair->msg, 0, sizeof(fd_repair_msg_t));
      98           0 :   repair->msg.kind            = FD_REPAIR_KIND_SHRED;
      99           0 :   repair->msg.shred.from      = repair->identity_key;
     100           0 :   repair->msg.shred.to        = *to;
     101           0 :   repair->msg.shred.ts        = ts;
     102           0 :   repair->msg.shred.nonce     = nonce;
     103           0 :   repair->msg.shred.slot      = slot;
     104           0 :   repair->msg.shred.shred_idx = shred_idx;
     105           0 :   return &repair->msg;
     106           0 : }
     107             : 
     108             : fd_repair_msg_t *
     109             : fd_repair_highest_shred( fd_repair_t *     repair,
     110             :                          fd_pubkey_t const * to,
     111             :                          ulong             ts,
     112             :                          uint              nonce,
     113             :                          ulong             slot,
     114           0 :                          ulong             shred_idx ) {
     115           0 :   memset(&repair->msg, 0, sizeof(fd_repair_msg_t));
     116           0 :   repair->msg.kind                    = FD_REPAIR_KIND_HIGHEST_SHRED;
     117           0 :   repair->msg.highest_shred.from      = repair->identity_key;
     118           0 :   repair->msg.highest_shred.to        = *to;
     119           0 :   repair->msg.highest_shred.ts        = ts;
     120           0 :   repair->msg.highest_shred.nonce     = nonce;
     121           0 :   repair->msg.highest_shred.slot      = slot;
     122           0 :   repair->msg.highest_shred.shred_idx = shred_idx;
     123           0 :   return &repair->msg;
     124           0 : }
     125             : 
     126             : fd_repair_msg_t *
     127             : fd_repair_orphan( fd_repair_t *     repair,
     128             :                   fd_pubkey_t const * to,
     129             :                   ulong             ts,
     130             :                   uint              nonce,
     131           0 :                   ulong             slot ) {
     132           0 :   memset(&repair->msg, 0, sizeof(fd_repair_msg_t));
     133           0 :   repair->msg.kind         = FD_REPAIR_KIND_ORPHAN;
     134           0 :   repair->msg.orphan.from  = repair->identity_key;
     135           0 :   repair->msg.orphan.to    = *to;
     136           0 :   repair->msg.orphan.ts    = ts;
     137           0 :   repair->msg.orphan.nonce = nonce;
     138           0 :   repair->msg.orphan.slot  = slot;
     139           0 :   return &repair->msg;
     140           0 : }
     141             : 
     142             : int
     143             : fd_repair_ping_de( fd_repair_ping_t * ping,
     144             :                    uchar      const * buf,
     145           0 :                    ulong              buf_sz ) {
     146           0 :   if( FD_UNLIKELY( buf_sz!=sizeof(fd_repair_ping_t) )) return -1;
     147             : 
     148           0 :   ping->kind = fd_uint_load_4_fast( buf );
     149           0 :   buf    += sizeof(uint);
     150             : 
     151           0 :   if( FD_UNLIKELY( ping->kind != FD_REPAIR_KIND_PING )) return -1;
     152             : 
     153             :   /* pong section */
     154             : 
     155           0 :   memcpy( &ping->ping.from, buf, sizeof(fd_pubkey_t) );
     156           0 :   buf += sizeof(fd_pubkey_t);
     157             : 
     158           0 :   memcpy( &ping->ping.hash, buf, sizeof(fd_hash_t) );
     159           0 :   buf += sizeof(fd_hash_t);
     160             : 
     161           0 :   memcpy( ping->ping.sig, buf, sizeof(fd_ed25519_sig_t) );
     162           0 :   buf += sizeof(fd_ed25519_sig_t);
     163           0 :   return 0;
     164           0 : }
     165             : 
     166             : int
     167             : fd_repair_ping_ser( fd_repair_ping_t const * ping,
     168             :                     uchar                    buf[static sizeof(fd_repair_ping_t)],
     169           0 :                     ulong                    buf_sz ) {
     170           0 :   ulong off = 0;
     171           0 :   if( FD_UNLIKELY( buf_sz!=sizeof(fd_repair_ping_t) )) return -1;
     172             : 
     173           0 :   FD_STORE( uint, buf+off, ping->kind );
     174           0 :   off += sizeof(uint);
     175             : 
     176           0 :   FD_STORE( fd_pubkey_t, buf+off, ping->ping.from );
     177           0 :   off += sizeof(fd_pubkey_t);
     178             : 
     179           0 :   FD_STORE( fd_hash_t, buf+off, ping->ping.hash );
     180           0 :   off += sizeof(fd_hash_t);
     181             : 
     182           0 :   memcpy( buf+off, ping->ping.sig, sizeof(fd_ed25519_sig_t) );
     183           0 :   off += sizeof(fd_ed25519_sig_t);
     184             : 
     185           0 :   return 0;
     186           0 : }