自学教程：C++ unix_time函数代码示例

static int handle_status(void *object, int number, uint8_t status, void *userdata){    Friend_Connections *const fr_c = (Friend_Connections *)object;    Friend_Conn *const friend_con = get_conn(fr_c, number);    if (!friend_con) {        return -1;    }    bool call_cb = 0;    if (status) {  /* Went online. */        call_cb = 1;        friend_con->status = FRIENDCONN_STATUS_CONNECTED;        friend_con->ping_lastrecv = unix_time();        friend_con->share_relays_lastsent = 0;        onion_set_friend_online(fr_c->onion_c, friend_con->onion_friendnum, status);    } else {  /* Went offline. */        if (friend_con->status != FRIENDCONN_STATUS_CONNECTING) {            call_cb = 1;            friend_con->dht_pk_lastrecv = unix_time();            onion_set_friend_online(fr_c->onion_c, friend_con->onion_friendnum, status);        }        friend_con->status = FRIENDCONN_STATUS_CONNECTING;        friend_con->crypt_connection_id = -1;        friend_con->hosting_tcp_relay = 0;    }    if (call_cb) {        unsigned int i;        for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {            if (friend_con->callbacks[i].status_callback) {                friend_con->callbacks[i].status_callback(                    friend_con->callbacks[i].callback_object,                    friend_con->callbacks[i].callback_id, status, userdata);            }        }    }    return 0;}

boxfile * obj_to_file(jobj * obj){	list_iter it;	jobj * item;	boxfile * f = (boxfile*) malloc(sizeof(boxfile));		memset(f, 0, sizeof(boxfile));	it = list_get_iter(obj->children);	for(; it; it = list_iter_next(it)) {		item = list_iter_getval(it);		if(!strcmp(item->key,"id")) f->id = strdup(item->value);		else if(!strcmp(item->key, "size")) f->size = atoll(item->value);		else if(!strcmp(item->key, "name")) f->name = strdup(item->value);		else if(!strcmp(item->key, "created_at")) f->ctime = unix_time(item->value);		else if(!strcmp(item->key, "modified_at")) f->mtime = unix_time(item->value);	}	return f;}

static int handle_announce_response(void *object, IP_Port source, const uint8_t *packet, uint16_t length){    Onion_Client *onion_c = object;    if (length < ONION_ANNOUNCE_RESPONSE_MIN_SIZE || length > ONION_ANNOUNCE_RESPONSE_MAX_SIZE)        return 1;    uint16_t len_nodes = length - ONION_ANNOUNCE_RESPONSE_MIN_SIZE;    uint8_t public_key[crypto_box_PUBLICKEYBYTES];    IP_Port ip_port;    uint32_t path_num;    uint32_t num = check_sendback(onion_c, packet + 1, public_key, &ip_port, &path_num);    if (num > onion_c->num_friends)        return 1;    uint8_t plain[1 + ONION_PING_ID_SIZE + len_nodes];    int len = -1;    if (num == 0) {        len = decrypt_data(public_key, onion_c->c->self_secret_key, packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,                           length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES), plain);    } else {        if (onion_c->friends_list[num - 1].status == 0)            return 1;        len = decrypt_data(public_key, onion_c->friends_list[num - 1].temp_secret_key,                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH,                           packet + 1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES,                           length - (1 + ONION_ANNOUNCE_SENDBACK_DATA_LENGTH + crypto_box_NONCEBYTES), plain);    }    if ((uint32_t)len != sizeof(plain))        return 1;    if (client_add_to_list(onion_c, num, public_key, ip_port, plain[0], plain + 1, path_num) == -1)        return 1;    if (len_nodes != 0) {        Node_format nodes[MAX_SENT_NODES];        int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, plain + 1 + ONION_PING_ID_SIZE, len_nodes, 0);        if (num_nodes <= 0)            return 1;        if (client_ping_nodes(onion_c, num, nodes, num_nodes, source) == -1)            return 1;    }    //TODO: LAN vs non LAN ips?, if we are connected only to LAN, are we offline?    onion_c->last_packet_recv = unix_time();    return 0;}

static int handle_fakeid_announce(void *object, const uint8_t *source_pubkey, const uint8_t *data, uint32_t length){    Onion_Client *onion_c = object;    if (length < FAKEID_DATA_MIN_LENGTH)        return 1;    if (length > FAKEID_DATA_MAX_LENGTH)        return 1;    int friend_num = onion_friend_num(onion_c, source_pubkey);    if (friend_num == -1)        return 1;    uint64_t no_replay;    memcpy(&no_replay, data + 1, sizeof(uint64_t));    net_to_host((uint8_t *) &no_replay, sizeof(no_replay));    if (no_replay <= onion_c->friends_list[friend_num].last_noreplay)        return 1;    onion_c->friends_list[friend_num].last_noreplay = no_replay;    onion_set_friend_DHT_pubkey(onion_c, friend_num, data + 1 + sizeof(uint64_t), current_time_monotonic());    onion_c->friends_list[friend_num].last_seen = unix_time();    uint16_t len_nodes = length - FAKEID_DATA_MIN_LENGTH;    if (len_nodes != 0) {        Node_format nodes[MAX_SENT_NODES];        int num_nodes = unpack_nodes(nodes, MAX_SENT_NODES, 0, data + 1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES,                                     len_nodes, 1);        if (num_nodes <= 0)            return 1;        int i;        for (i = 0; i < num_nodes; ++i) {            uint8_t family = nodes[i].ip_port.ip.family;            if (family == AF_INET || family == AF_INET6) {                DHT_getnodes(onion_c->dht, &nodes[i].ip_port, nodes[i].client_id, onion_c->friends_list[friend_num].fake_client_id);            } else if (family == TCP_INET || family == TCP_INET6) {                if (onion_c->friends_list[friend_num].tcp_relay_node_callback) {                    void *obj = onion_c->friends_list[friend_num].tcp_relay_node_callback_object;                    uint32_t number = onion_c->friends_list[friend_num].tcp_relay_node_callback_number;                    onion_c->friends_list[friend_num].tcp_relay_node_callback(obj, number, nodes[i].ip_port, nodes[i].client_id);                }            }        }    }    return 0;}

void do_onion_client(Onion_Client *onion_c){    unsigned int i;    if (onion_c->last_run == unix_time())        return;    for (i = 0; i < NODE_POPULATE_TIMES; ++i)        populate_path_nodes(onion_c);    do_announce(onion_c);    if (onion_isconnected(onion_c)) {        for (i = 0; i < onion_c->num_friends; ++i) {            do_friend(onion_c, i);        }    }    onion_c->last_run = unix_time();}

/** Truncate an Ext2 inode. * @todo		Triple indirect blocks. * @param inode		Inode to truncate. Should be locked. * @param size		New size of node. * @return		Status code describing result of the operation. */static status_t ext2_inode_truncate(ext2_inode_t *inode, offset_t size) {	status_t ret;	size_t count;	int i;	assert(!(inode->mount->parent->flags & FS_MOUNT_RDONLY));	if(inode->size <= size) {		return STATUS_SUCCESS;	}	/* TODO. I'm lazy. */	if(size > 0) {		kprintf(LOG_WARN, "ext2: truncate not yet support for size > 0/n");		return STATUS_NOT_IMPLEMENTED;	}	/* Don't support tri-indirect yet, check now so we don't discover	 * one when we've already freed part of the file. */	if(le32_to_cpu(inode->disk.i_block[EXT2_TIND_BLOCK]) != 0) {		kprintf(LOG_WARN, "ext2: tri-indirect blocks not yet supported!/n");		return STATUS_NOT_IMPLEMENTED;	}	count = ROUND_UP(inode->size, inode->mount->block_size) / inode->mount->block_size;	file_map_invalidate(inode->map, 0, count);	vm_cache_resize(inode->cache, size);	inode->size = size;	inode->disk.i_mtime = cpu_to_le32(USECS2SECS(unix_time()));	ext2_inode_flush(inode);	for(i = 0; i < EXT2_N_BLOCKS; i++) {		if(le32_to_cpu(inode->disk.i_block[i]) == 0) {			continue;		} else if(i < EXT2_NDIR_BLOCKS) {			ret = ext2_inode_block_free(inode, &inode->disk.i_block[i]);			if(ret != STATUS_SUCCESS) {				return ret;			}		} else if(i == EXT2_IND_BLOCK) {			ret = ext2_inode_iblock_free(inode, &inode->disk.i_block[i]);			if(ret != STATUS_SUCCESS) {				return ret;			}		} else if(i == EXT2_DIND_BLOCK) {			ret = ext2_inode_biblock_free(inode, &inode->disk.i_block[i]);			if(ret != STATUS_SUCCESS) {				return ret;			}		}	}	return STATUS_SUCCESS;}

/* Send a LAN discovery packet every LAN_DISCOVERY_INTERVAL seconds. */static void LANdiscovery(Friend_Connections *fr_c){    if (fr_c->last_LANdiscovery + LAN_DISCOVERY_INTERVAL < unix_time()) {        const uint16_t first = fr_c->next_LANport;        uint16_t last = first + PORTS_PER_DISCOVERY;        last = last > TOX_PORTRANGE_TO ? TOX_PORTRANGE_TO : last;        // Always send to default port        lan_discovery_send(net_htons(TOX_PORT_DEFAULT), fr_c->dht);        // And check some extra ports        for (uint16_t port = first; port < last; port++) {            lan_discovery_send(net_htons(port), fr_c->dht);        }        // Don't include default port in port range        fr_c->next_LANport = last != TOX_PORTRANGE_TO ? last : TOX_PORTRANGE_FROM + 1;        fr_c->last_LANdiscovery = unix_time();    }}

/******************************************************************************   Description:      Conversion between the UNIX time and the (year, month,      day, hour, minute, second) representation. If "time" is      non-zero, this function returns the year, month,      day, hour, minute and second as converted from "time".   Inputs:      time - the UNIX time;   Outputs:      year - year (e.g. 1995; >= 1970)      month - month number (1 through 12)      day - day number (1, 2, 3, ...)      hour - hour (0 through 23)      minute - minute (0 through 59)      second - second (0 through 59)   Returns:      The function returns 0 on success or -1 on failure (an      argument is out of range).   Notes:      See misc_unix_time.c in cpc100/lib004.******************************************************************************/int RPGCS_unix_time_to_ymdhms( time_t time, int *year, int *month, int *day,                               int *hour, int *minute, int *second ) {    /* Insure the time value is not zero. */    if( time == 0 )        return(-1);    return( unix_time( &time, year, month, day, hour, minute, second ) );    /* End of RPGCS_unix_time_to_ymdhms() */}

/** Get information about a memory file. * @param handle	File handle structure. * @param info		Information structure to fill in. */static void memory_file_info(file_handle_t *handle, file_info_t *info) {	memory_file_t *file = (memory_file_t *)handle->file;	info->id = 0;	info->mount = 0;	info->type = file->file.type;	info->block_size = 1;	info->size = file->size;	info->links = 1;	info->created = info->accessed = info->modified = unix_time();}

static void do_TCP_confirmed(TCP_Server *TCP_server){    uint32_t i;    for (i = 0; i < TCP_server->size_accepted_connections; ++i) {        TCP_Secure_Connection *conn = &TCP_server->accepted_connection_array[i];        if (conn->status != TCP_STATUS_CONFIRMED)            continue;        if (is_timeout(conn->last_pinged, TCP_PING_FREQUENCY)) {            uint8_t ping[1 + sizeof(uint64_t)];            ping[0] = TCP_PACKET_PING;            uint64_t ping_id = random_64b();            if (!ping_id)                ++ping_id;            memcpy(ping + 1, &ping_id, sizeof(uint64_t));            int ret = write_packet_TCP_secure_connection(conn, ping, sizeof(ping));            if (ret == 1) {                conn->last_pinged = unix_time();                conn->ping_id = ping_id;            }        }        if (conn->ping_id && is_timeout(conn->last_pinged, TCP_PING_TIMEOUT)) {            kill_TCP_connection(conn);            del_accepted(TCP_server, i);            continue;        }        send_pending_data(conn);        uint8_t packet[MAX_PACKET_SIZE];        int len;        while ((len = read_packet_TCP_secure_connection(conn->sock, &conn->next_packet_length, conn->shared_key,                      conn->recv_nonce, packet, sizeof(packet)))) {            if (len == -1) {                kill_TCP_connection(conn);                del_accepted(TCP_server, i);                break;            }            if (handle_TCP_packet(TCP_server, i, packet, len) == -1) {                kill_TCP_connection(conn);                del_accepted(TCP_server, i);                break;            }        }    }}

static int handle_fakeid_announce(void *object, uint8_t *source_pubkey, uint8_t *data, uint32_t length){    Onion_Client *onion_c = object;    if (length < FAKEID_DATA_MIN_LENGTH)        return 1;    if (length > FAKEID_DATA_MAX_LENGTH)        return 1;    if ((length - FAKEID_DATA_MIN_LENGTH) % sizeof(Node_format) != 0)        return 1;    int friend_num = onion_friend_num(onion_c, source_pubkey);    if (friend_num == -1)        return 1;    uint64_t no_replay;    net_to_host(data + 1, sizeof(no_replay));    memcpy(&no_replay, data + 1, sizeof(uint64_t));    if (no_replay <= onion_c->friends_list[friend_num].last_noreplay)        return 1;    onion_c->friends_list[friend_num].last_noreplay = no_replay;    if (memcmp(data + 1 + sizeof(uint64_t), onion_c->friends_list[friend_num].fake_client_id,               crypto_box_PUBLICKEYBYTES) != 0) {        DHT_delfriend(onion_c->dht, onion_c->friends_list[friend_num].fake_client_id);        onion_c->friends_list[friend_num].last_seen = unix_time();        if (DHT_addfriend(onion_c->dht, data + 1 + sizeof(uint64_t)) == 1) {            return 1;        }        onion_c->friends_list[friend_num].is_fake_clientid = 1;        memcpy(onion_c->friends_list[friend_num].fake_client_id, data + 1 + sizeof(uint64_t), crypto_box_PUBLICKEYBYTES);    }    uint16_t num_nodes = (length - FAKEID_DATA_MIN_LENGTH) / sizeof(Node_format);    Node_format nodes[num_nodes];    memcpy(nodes, data + 1 + sizeof(uint64_t) + crypto_box_PUBLICKEYBYTES, sizeof(nodes));    uint32_t i;    for (i = 0; i < num_nodes; ++i) {        to_host_family(&nodes[i].ip_port.ip);        DHT_getnodes(onion_c->dht, &nodes[i].ip_port, nodes[i].client_id, onion_c->friends_list[friend_num].fake_client_id);    }    return 0;}

/* Create a new path or use an old suitable one (if pathnum is valid) * or a rondom one from onion_paths. * * return -1 on failure * return 0 on success * * TODO: Make this function better, it currently probably is vulnerable to some attacks that * could de anonimize us. */static int random_path(DHT *dht, Onion_Client_Paths *onion_paths, uint32_t pathnum, Onion_Path *path){    if (pathnum >= NUMBER_ONION_PATHS)        pathnum = rand() % NUMBER_ONION_PATHS;    if (is_timeout(onion_paths->last_path_success[pathnum], ONION_PATH_TIMEOUT)            || is_timeout(onion_paths->path_creation_time[pathnum], ONION_PATH_MAX_LIFETIME)) {        Node_format nodes[3];        if (random_nodes_path(dht, nodes, 3) != 3)            return -1;        if (create_onion_path(dht, &onion_paths->paths[pathnum], nodes) == -1)            return -1;        onion_paths->last_path_success[pathnum] = unix_time() + ONION_PATH_FIRST_TIMEOUT - ONION_PATH_TIMEOUT;        onion_paths->path_creation_time[pathnum] = unix_time();    }    memcpy(path, &onion_paths->paths[pathnum], sizeof(Onion_Path));    return 0;}

static int handle_packet(void *object, int number, uint8_t *data, uint16_t length, void *userdata){    if (length == 0)        return -1;    Friend_Connections *fr_c = object;    Friend_Conn *friend_con = get_conn(fr_c, number);    if (!friend_con)        return -1;    if (data[0] == PACKET_ID_FRIEND_REQUESTS) {        if (fr_c->fr_request_callback)            fr_c->fr_request_callback(fr_c->fr_request_object, friend_con->real_public_key, data, length);        return 0;    } else if (data[0] == PACKET_ID_ALIVE) {        friend_con->ping_lastrecv = unix_time();        return 0;    } else if (data[0] == PACKET_ID_SHARE_RELAYS) {        Node_format nodes[MAX_SHARED_RELAYS];        int n;        if ((n = unpack_nodes(nodes, MAX_SHARED_RELAYS, NULL, data + 1, length - 1, 1)) == -1)            return -1;        int j;        for (j = 0; j < n; j++) {            friend_add_tcp_relay(fr_c, number, nodes[j].ip_port, nodes[j].public_key);        }        return 0;    }    unsigned int i;    for (i = 0; i < MAX_FRIEND_CONNECTION_CALLBACKS; ++i) {        if (friend_con->callbacks[i].data_callback)            friend_con->callbacks[i].data_callback(                friend_con->callbacks[i].data_callback_object,                friend_con->callbacks[i].data_callback_id, data, length, userdata);        friend_con = get_conn(fr_c, number);        if (!friend_con)            return -1;    }    return 0;}

static int handle_sendnodes(Group_Chat *chat, IP_Port source, int peernum, const uint8_t *data, uint32_t len){    if ((uint32_t)peernum >= chat->numpeers)        return 1;    if (len > sizeof(sendnodes_data) || len < sizeof(uint64_t))        return 1;    if ((len - sizeof(uint64_t)) % sizeof(groupchat_nodes) != 0)        return 1;    if (is_timeout(chat->group[peernum].last_pinged, GROUP_PING_TIMEOUT))        return 1;    sendnodes_data contents;    memcpy(&contents, data, len);    if (contents.pingid != chat->group[peernum].pingid)        return 1;    uint16_t numnodes = (len - sizeof(contents.pingid)) / sizeof(groupchat_nodes);    uint32_t i;    IPPTs ippts_send;    ippts_send.timestamp = unix_time();    for (i = 0; i < numnodes; ++i) {        if (peer_okping(chat, contents.nodes[i].client_id) > 0) {            int peern = peer_in_chat(chat, contents.nodes[i].client_id);            if (peern == -1) { /*NOTE: This is just for testing and will be removed later.*/                peern = addpeer(chat, contents.nodes[i].client_id);            }            if (peern == -1)                continue;            to_host_family(&contents.nodes[i].ip_port.ip);            send_getnodes(chat, contents.nodes[i].ip_port, peern);            if (chat->assoc) {                ippts_send.ip_port = contents.nodes[i].ip_port;                Assoc_add_entry(chat->assoc, contents.nodes[i].client_id, &ippts_send, NULL, 0);            }        }    }    int ok = add_closepeer(chat, chat->group[peernum].client_id, source);    return 0;}

static void do_friend(Onion_Client *onion_c, uint16_t friendnum){    if (friendnum >= onion_c->num_friends)        return;    if (onion_c->friends_list[friendnum].status == 0)        return;    uint32_t i, count = 0;    Onion_Node *list_nodes = onion_c->friends_list[friendnum].clients_list;    for (i = 0; i < MAX_ONION_CLIENTS; ++i) {        if (is_timeout(list_nodes[i].timestamp, ONION_NODE_TIMEOUT))            continue;        ++count;        if (is_timeout(list_nodes[i].last_pinged, ANNOUNCE_FRIEND)) {            if (client_send_announce_request(onion_c, friendnum + 1, list_nodes[i].ip_port, list_nodes[i].client_id, 0) == 0) {                list_nodes[i].last_pinged = unix_time();            }        }    }    if (count < MAX_ONION_CLIENTS / 2) {        Node_format nodes_list[MAX_SENT_NODES];        uint32_t num_nodes = get_close_nodes(onion_c->dht, onion_c->friends_list[i].real_client_id, nodes_list,                                             rand() % 2 ? AF_INET : AF_INET6, rand() % 2, 1);        for (i = 0; i < num_nodes; ++i)            client_send_announce_request(onion_c, friendnum + 1, nodes_list[i].ip_port, nodes_list[i].client_id, 0);    }    /* send packets to friend telling them our fake DHT id. */    if (is_timeout(onion_c->friends_list[friendnum].last_fakeid_sent, ONION_FAKEID_INTERVAL))        if (send_fakeid_announce(onion_c, friendnum) > 3)            onion_c->friends_list[friendnum].last_fakeid_sent = unix_time();}

/* main friend_connections loop. */void do_friend_connections(Friend_Connections *fr_c, void *userdata){    const uint64_t temp_time = unix_time();    for (uint32_t i = 0; i < fr_c->num_cons; ++i) {        Friend_Conn *const friend_con = get_conn(fr_c, i);        if (friend_con) {            if (friend_con->status == FRIENDCONN_STATUS_CONNECTING) {                if (friend_con->dht_pk_lastrecv + FRIEND_DHT_TIMEOUT < temp_time) {                    if (friend_con->dht_lock) {                        DHT_delfriend(fr_c->dht, friend_con->dht_temp_pk, friend_con->dht_lock);                        friend_con->dht_lock = 0;                        memset(friend_con->dht_temp_pk, 0, CRYPTO_PUBLIC_KEY_SIZE);                    }                }                if (friend_con->dht_ip_port_lastrecv + FRIEND_DHT_TIMEOUT < temp_time) {                    friend_con->dht_ip_port.ip.family = 0;                }                if (friend_con->dht_lock) {                    if (friend_new_connection(fr_c, i) == 0) {                        set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, friend_con->dht_ip_port, 0);                        connect_to_saved_tcp_relays(fr_c, i, (MAX_FRIEND_TCP_CONNECTIONS / 2)); /* Only fill it half up. */                    }                }            } else if (friend_con->status == FRIENDCONN_STATUS_CONNECTED) {                if (friend_con->ping_lastsent + FRIEND_PING_INTERVAL < temp_time) {                    send_ping(fr_c, i);                }                if (friend_con->share_relays_lastsent + SHARE_RELAYS_INTERVAL < temp_time) {                    send_relays(fr_c, i);                }                if (friend_con->ping_lastrecv + FRIEND_CONNECTION_TIMEOUT < temp_time) {                    /* If we stopped receiving ping packets, kill it. */                    crypto_kill(fr_c->net_crypto, friend_con->crypt_connection_id);                    friend_con->crypt_connection_id = -1;                    handle_status(fr_c, i, 0, userdata); /* Going offline. */                }            }        }    }    if (fr_c->local_discovery_enabled) {        LANdiscovery(fr_c);    }}

/* * Add a peer to the group chat. * * return peernum if success or peer already in chat. * return -1 if error. */static int addpeer(Group_Chat *chat, uint8_t *client_id){    int peernum = peer_in_chat(chat, client_id);    if (peernum != -1)        return peernum;    Group_Peer *temp;    temp = realloc(chat->group, sizeof(Group_Peer) * (chat->numpeers + 1));    if (temp == NULL)        return -1;    memset(&(temp[chat->numpeers]), 0, sizeof(Group_Peer));    chat->group = temp;    id_copy(chat->group[chat->numpeers].client_id, client_id);    chat->group[chat->numpeers].last_recv = unix_time();    chat->group[chat->numpeers].last_recv_msgping = unix_time();    ++chat->numpeers;    return (chat->numpeers - 1);}

static int ping_groupchat(Group_Chats *g_c, int groupnumber){    Group_c *g = get_group_c(g_c, groupnumber);    if (!g)        return -1;    if (is_timeout(g->last_sent_ping, GROUP_PING_INTERVAL)) {        if (group_ping_send(g_c, groupnumber) != -1) /* Ping */            g->last_sent_ping = unix_time();    }    return 0;}

/* * Add a peer to the group chat. * * return peer_index if success or peer already in chat. * return -1 if error. */static int addpeer(Group_Chats *g_c, int groupnumber, const uint8_t *real_pk, const uint8_t *temp_pk,                   uint16_t peer_number){    Group_c *g = get_group_c(g_c, groupnumber);    if (!g)        return -1;    //TODO    int peer_index = peer_in_chat(g, real_pk);    if (peer_index != -1) {        id_copy(g->group[peer_index].temp_pk, temp_pk);        if (g->group[peer_index].peer_number != peer_number)            return -1;        return peer_index;    }    peer_index = get_peer_index(g, peer_number);    if (peer_index != -1)        return -1;    Group_Peer *temp;    temp = realloc(g->group, sizeof(Group_Peer) * (g->numpeers + 1));    if (temp == NULL)        return -1;    memset(&(temp[g->numpeers]), 0, sizeof(Group_Peer));    g->group = temp;    id_copy(g->group[g->numpeers].real_pk, real_pk);    id_copy(g->group[g->numpeers].temp_pk, temp_pk);    g->group[g->numpeers].peer_number = peer_number;    g->group[g->numpeers].last_recv = unix_time();    ++g->numpeers;    add_to_closest(g_c, groupnumber, real_pk, temp_pk);    if (g_c->peer_namelistchange)        g_c->peer_namelistchange(g_c->m, groupnumber, g->numpeers - 1, CHAT_CHANGE_PEER_ADD,                                 g_c->group_namelistchange_userdata);    return (g->numpeers - 1);}

static int good_to_ping(Last_Pinged *last_pinged, uint8_t *last_pinged_index, const uint8_t *client_id){    uint32_t i;    for (i = 0; i < MAX_STORED_PINGED_NODES; ++i) {        if (!is_timeout(last_pinged[i].timestamp, MIN_NODE_PING_TIME))            if (memcmp(last_pinged[i].client_id, client_id, crypto_box_PUBLICKEYBYTES) == 0)                return 0;    }    memcpy(last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].client_id, client_id, crypto_box_PUBLICKEYBYTES);    last_pinged[*last_pinged_index % MAX_STORED_PINGED_NODES].timestamp = unix_time();    ++*last_pinged_index;    return 1;}

/** Read to an Ext2 inode. * @param inode		Inode to write to. * @param buf		Buffer containing data to write. * @param count		Number of bytes to write. * @param offset	Offset into inode to write to. * @param nonblock	Whether the operation is required to not block. * @return		Status code describing result of the operation. */status_t ext2_inode_write(ext2_inode_t *inode, const void *buf, size_t count, offset_t offset,                          bool nonblock, size_t *bytesp) {	uint32_t start, blocks, i;	uint64_t raw;	status_t ret;	mutex_lock(&inode->lock);	/* Attempt to resize the node if necessary. */	if((offset + count) > inode->size) {    		inode->size = offset + count;		vm_cache_resize(inode->cache, inode->size);		ext2_inode_flush(inode);	}	/* Now we need to reserve blocks on the filesystem. */	start = offset / inode->mount->block_size;	blocks = (ROUND_UP(offset + count, inode->mount->block_size) / inode->mount->block_size) - start;	for(i = 0; i < blocks; i++) {		ret = file_map_lookup(inode->map, start + i, &raw);		if(ret != STATUS_SUCCESS) {			dprintf("ext2: failed to lookup raw block for inode %p(%" PRIu32 ") (%d)/n",			        inode, inode->num, ret);			return ret;		}		/* If the block number is 0, then allocate a new block. The		 * call to ext2_inode_block_alloc() invalidates the file map		 * entries. */		if(raw == 0) {			ret = ext2_inode_block_alloc(inode, start + i, nonblock);			if(ret != STATUS_SUCCESS) {				dprintf("ext2: failed to allocate raw block for inode %p(%" PRIu32 ") (%d)/n",				        inode, inode->num, ret);				return ret;			}		}	}	mutex_unlock(&inode->lock);	ret = vm_cache_write(inode->cache, buf, count, offset, nonblock, bytesp);	if(*bytesp) {		inode->disk.i_mtime = cpu_to_le32(USECS2SECS(unix_time()));	}	return ret;}

/* Start a secure connection with other peer who has public_key and ip_port. * *  return -1 if failure. *  return crypt_connection_id of the initialized connection if everything went well. */int crypto_connect(Net_Crypto *c, uint8_t *public_key, IP_Port ip_port){    uint32_t i;    int id_existing = getcryptconnection_id(c, public_key);    if (id_existing != -1) {        IP_Port c_ip = connection_ip(c->lossless_udp, c->crypto_connections[id_existing].number);        if (ipport_equal(&c_ip, &ip_port))            return -1;    }    if (realloc_cryptoconnection(c, c->crypto_connections_length + 1) == -1            || c->crypto_connections == NULL)        return -1;    memset(&(c->crypto_connections[c->crypto_connections_length]), 0, sizeof(Crypto_Connection));    c->crypto_connections[c->crypto_connections_length].number = ~0;    for (i = 0; i <= c->crypto_connections_length; ++i) {        if (c->crypto_connections[i].status == CRYPTO_CONN_NO_CONNECTION) {            int id_new = new_connection(c->lossless_udp, ip_port);            if (id_new == -1)                return -1;            c->crypto_connections[i].number = id_new;            c->crypto_connections[i].status = CRYPTO_CONN_HANDSHAKE_SENT;            random_nonce(c->crypto_connections[i].recv_nonce);            memcpy(c->crypto_connections[i].public_key, public_key, crypto_box_PUBLICKEYBYTES);            crypto_box_keypair(c->crypto_connections[i].sessionpublic_key, c->crypto_connections[i].sessionsecret_key);            c->crypto_connections[i].timeout = unix_time() + CRYPTO_HANDSHAKE_TIMEOUT;            if (c->crypto_connections_length == i)                ++c->crypto_connections_length;            if (send_cryptohandshake(c, id_new, public_key,  c->crypto_connections[i].recv_nonce,                                     c->crypto_connections[i].sessionpublic_key) == 1) {                increment_nonce(c->crypto_connections[i].recv_nonce);                return i;            }            return -1; /* This should never happen. */        }    }    return -1;}

static int send_getnodes(Group_Chat *chat, IP_Port ip_port, int peernum){    if ((uint32_t)peernum >= chat->numpeers)        return -1;    if (!is_timeout(chat->group[peernum].last_pinged, PING_TIMEOUT))        return -1;    getnodes_data contents;    contents.pingid = ((uint64_t)random_int() << 32) + random_int();    chat->group[peernum].last_pinged = unix_time();    chat->group[peernum].pingid = contents.pingid;    return send_groupchatpacket(chat, ip_port, chat->group[peernum].client_id, (uint8_t *)&contents, sizeof(contents), 48);}

/* Ping all the valid nodes in the toping list every TIME_TOPING seconds. * This function must be run at least once every TIME_TOPING seconds. */void do_toping(PING *ping){    if (!is_timeout(ping->last_toping, TIME_TOPING))        return;    ping->last_toping = unix_time();    size_t i;    for (i = 0; i < MAX_TOPING; ++i) {        if (!ip_isset(&ping->toping[i].ip_port.ip))            return;        send_ping_request(ping, ping->toping[i].ip_port, ping->toping[i].client_id);        ip_reset(&ping->toping[i].ip_port.ip);    }}

/* Callback for DHT ip_port changes. */static void dht_ip_callback(void *object, int32_t number, IP_Port ip_port){    Friend_Connections *fr_c = object;    Friend_Conn *friend_con = get_conn(fr_c, number);    if (!friend_con)        return;    if (friend_con->crypt_connection_id == -1) {        friend_new_connection(fr_c, number);    }    set_direct_ip_port(fr_c->net_crypto, friend_con->crypt_connection_id, ip_port);    friend_con->dht_ip_port = ip_port;    friend_con->dht_ip_port_lastrecv = unix_time();}

/* Set if friend is online or not. * NOTE: This function is there and should be used so that we don't send useless packets to the friend if he is online. * * is_online 1 means friend is online. * is_online 0 means friend is offline * * return -1 on failure. * return 0 on success. */int onion_set_friend_online(Onion_Client *onion_c, int friend_num, uint8_t is_online){    if ((uint32_t)friend_num >= onion_c->num_friends)        return -1;    if (is_online == 0 && onion_c->friends_list[friend_num].is_online == 1)        onion_c->friends_list[friend_num].last_seen = unix_time();    onion_c->friends_list[friend_num].is_online = is_online;    /* This should prevent some clock related issues */    if (!is_online)        onion_c->friends_list[friend_num].last_noreplay = 0;    return 0;}

static int client_add_to_list(Onion_Client *onion_c, uint32_t num, uint8_t *public_key, IP_Port ip_port,                              uint8_t *ping_id){    if (num > onion_c->num_friends)        return -1;    Onion_Node *list_nodes = NULL;    uint8_t *reference_id = NULL;    if (num == 0) {        list_nodes = onion_c->clients_announce_list;        reference_id = onion_c->dht->c->self_public_key;    } else {        list_nodes = onion_c->friends_list[num - 1].clients_list;        reference_id = onion_c->friends_list[num - 1].real_client_id;    }    memcpy(cmp_public_key, reference_id, crypto_box_PUBLICKEYBYTES);    qsort(list_nodes, MAX_ONION_CLIENTS, sizeof(Onion_Node), cmp_entry);    int index = -1;    if (is_timeout(list_nodes[0].timestamp, ONION_NODE_TIMEOUT)            || id_closest(reference_id, list_nodes[0].client_id, public_key) == 2) {        index = 0;    }    uint32_t i;    for (i = 0; i < MAX_ONION_CLIENTS; ++i) {        if (memcmp(list_nodes[i].client_id, public_key, crypto_box_PUBLICKEYBYTES) == 0) {            index = i;            break;        }    }    if (index == -1)        return 0;    memcpy(list_nodes[index].client_id, public_key, CLIENT_ID_SIZE);    list_nodes[index].ip_port = ip_port;    memcpy(list_nodes[index].ping_id, ping_id, ONION_PING_ID_SIZE);    list_nodes[index].timestamp = unix_time();    list_nodes[index].last_pinged = 0;    return 0;}

static int send_ping(const Friend_Connections *fr_c, int friendcon_id){    Friend_Conn *friend_con = get_conn(fr_c, friendcon_id);    if (!friend_con)        return -1;    uint8_t ping = PACKET_ID_ALIVE;    int64_t ret = write_cryptpacket(fr_c->net_crypto, friend_con->crypt_connection_id, &ping, sizeof(ping), 0);    if (ret != -1) {        friend_con->ping_lastsent = unix_time();        return 0;    }    return -1;}

//replace first bad (or empty) node with this one//return 0 if successfull//return 1 if not (list contains no bad nodes)int replace_bad(Client_data * list, uint32_t length, char * client_id, IP_Port ip_port)//tested{    uint32_t i;    uint32_t temp_time = unix_time();    for(i = 0; i < length; i++)    {        if(list[i].timestamp + BAD_NODE_TIMEOUT < temp_time)//if node is bad.        {            memcpy(list[i].client_id, client_id, CLIENT_ID_SIZE);            list[i].ip_port = ip_port;            list[i].timestamp = temp_time;            return 0;        }    }    return 1;    }