int txop_ward_init(shpeer_t *cli_peer, tx_ward_t *ward)
{
unsigned char context[128];
shkey_t sig_key;
tx_context_t ctx;
tx_t *tx;
int err;
if (ward->ward_stamp == SHTIME_UNDEFINED)
ward->ward_stamp = shtime();
if (ward->ward_expire == SHTIME_UNDEFINED)
ward->ward_expire = shtime_adj(shtime(), MAX_SHARE_SESSION_TIME);
memcpy(&ward->ward_tx.tx_peer, shpeer_kpriv(sharedaemon_peer()), sizeof(shpeer_t));
memset(&ctx, 0, sizeof(ctx));
err = inittx_context(&ctx, get_tx_key(ward), ashkey_uniq());
if (err)
return (err);
err = tx_save(&ctx);
if (err)
return (err);
/* store key reference to generated context */
memcpy(&ward->ward_ctx, &ctx.ctx_tx.tx_key, sizeof(ward->ward_ctx));
return (0);
}
int shcert_init_default(shcert_t *cert)
{
int i;
/* certificate version */
cert->cert_ver = 3;
/* certificate's issuer peer entity */
memcpy(&cert->cert_sub.ent_peer, ashpeer(), sizeof(cert->cert_sub.ent_peer));
/* set birth and expiration time-stamps */
cert->cert_sub.ent_sig.sig_stamp = shtime_adj(shtime(), -1);
cert->cert_sub.ent_sig.sig_expire =
shtime_adj(shtime(), SHARE_DEFAULT_EXPIRE_TIME);
/* fill with random serial number */
shcert_init_serial(shcert_sub_ser(cert));
}
void generate_asset_signature(tx_asset_t *asset, shpeer_t *peer)
{
shkey_t *sig_key;
uint64_t crc;
if (asset->ass.ass_expire == SHTIME_UNDEFINED)
asset->ass.ass_expire = shtime_adj(shtime(), SHARE_DEFAULT_EXPIRE_TIME);
crc = shcrc((unsigned char *)asset->ass_data, asset->ass_size);
sig_key = shkey_cert(shpeer_kpriv(peer), crc, asset->ass.ass_expire);
memcpy(&asset->ass.ass_sig, sig_key, sizeof(shkey_t));
shkey_free(&sig_key);
}
int shpam_shadow_session(shfs_ino_t *file, shseed_t *seed, shkey_t **sess_p, shtime_t *expire_p)
{
shadow_t *ent;
shadow_t save;
shkey_t *sess_key;
shkey_t *ret_key;
shkey_t *seed_key;
shtime_t stamp;
shtime_t now;
uint64_t crc;
int err;
if (!file->tree)
return (SHERR_INVAL);
err = shpam_shadow_load(file, seed->seed_uid, &save);
if (err) {
return (err);
}
now = shtime();
if (shtime_after(now, save.sh_expire)) {
/* generate new session key with default expiration */
stamp = shtime_adj(now, MAX_SHARE_SESSION_TIME);
sess_key = _shpam_shadow_session_gen(seed, &save.sh_id, stamp);
if (!sess_key)
return (SHERR_KEYREVOKED);
save.sh_expire = stamp;
memcpy(&save.sh_sess, sess_key, sizeof(save.sh_sess));
err = shpam_shadow_store(file, &save);
shkey_free(&sess_key);
if (err) {
return (err);
}
}
if (expire_p)
*expire_p = save.sh_expire;
if (sess_p) {
ret_key = (shkey_t *)calloc(1, sizeof(shkey_t));
memcpy(ret_key, &save.sh_sess, sizeof(shkey_t));
*sess_p = ret_key;
}
return (0);
}
/**
* Creates a new bond with the local shared as sender.
* @note Set the bond state to confirm to initiate transaction.
*/
tx_bond_t *create_bond(shkey_t *bond_key, double duration, double fee, double basis)
{
bond = (tx_bond_t *)calloc(1, sizeof(tx_bond_t));
if (!bond)
return (SHERR_NOMEM);
local_transid_generate(TX_BOND, &bond->tx);
bond->bond_stamp = shtime64();
bond->bond_stamp = shtime_adj(bond->bond_stamp, duration);
bond->bond_credit = (uint64_t)(fee / 0.00000001);
bond->bond_basis = (uint32_t)(basis * 10000);
bond->bond_state = TXBOND_PENDING;
/* authenticate bond info */
generate_bond_signature(bond);
err = tx_init(NULL, (tx_t *)bond, TX_BOND);
if (err)
return (err);
return (bond);
}
int sharedaemon_bcast_recv(void)
{
struct sockaddr_in addr;
socklen_t addr_len;
struct timeval to;
fd_set read_set;
shpeer_t *peer;
char dgram[512];
ssize_t r_len;
int err;
err = bcast_recv_init();
if (err) {
return (err);
}
FD_ZERO(&read_set);
FD_SET(_bcast_recv_fd, &read_set);
/* nonblocking read */
memset(&to, 0, sizeof(to));
err = select(_bcast_recv_fd+1, &read_set, NULL, NULL, &to);
if (err < 0) {
return (-errno);
}
if (err == 0) {
//fprintf(stderr, "\rWaiting for select(_bcast_recv_fd)..");
//fflush(stderr);
return (0); /* nothing to read */
}
addr_len = sizeof(addr);
memset(&addr, 0, addr_len);
r_len = recvfrom(_bcast_recv_fd,
dgram, sizeof dgram, 0, &addr, &addr_len);
if (r_len < 0) {
fprintf(stderr, "DEBUG: %d = recvfrom()\n", r_len);
return (-errno);
}
/* and who are you? */
if (r_len < sizeof(shpeer_t)) {
fprintf(stderr, "DEBUG: <%d bytes> pending..\n", r_len);
return (SHERR_INVAL);
}
#if 0
now = shtime();
tx = (tx_t *)dgram;
if (shtime_after(tx->tx_stamp, now) ||
shtime_before(tx->tx_stamp, shtime_adj(now, -BROADCAST_TIMEOUT))) {
/* broadcast message must indicate sane time-frame. */
return (SHERR_TIME);
}
switch (tx->tx_op) {
case TX_PEER:
peer_tx = (tx_peer_t *)dgram;
if (0 != shkey_cmp(&tx->tx_peer, shpeer_kpriv(&peer_tx->peer)))
return (SHERR_INVAL); /* only accept self-referencing broadcast */
}
#endif
/* share-daemon broadcasting it's peer address. */
peer = (shpeer_t *)dgram;
if (!shkey_cmp(shpeer_kpub(sharedaemon_peer()), shpeer_kpub(peer))) {
/* this is not a shared peer */
return (0); /* all done */
}
if (!shkey_cmp(shpeer_kpub(sharedaemon_peer()), shpeer_kpub(peer))) {
fprintf(stderr, "DEBUG: invalid key\n");
/* this is a peer referencing ourselves. */
//err = sharedaemon_netclient_alias(&addr);
}
switch (peer->type) {
case SHNET_PEER_LOCAL:
case SHNET_PEER_IPV4:
/*
memset(&addr, '\000', sizeof(struct sockaddr_in));
memcpy(&addr, &peer_tx->peer.addr, sizeof(peer_tx->peer.addr));
*/
fprintf(stderr, "DEBUG: received UDP broadcast with peer \"%s\"\n", shpeer_print(peer));
fprintf(stderr, "DEBUG: received UDP broadcast for \"%s\" port %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
if (!peer->addr.sin_port)
break; /* otay */
addr.sin_family = AF_INET;
err = sharedaemon_netclient_conn(peer, &addr);
if (err)
return (err);
break;
}
fprintf(stderr, "DEBUG: processed bcast recv\n");
return (0);
}
